diff --git a/tests/events/main.c b/tests/events/main.c
index 7acbe9c039..2b1a85c382 100644
--- a/tests/events/main.c
+++ b/tests/events/main.c
@@ -28,8 +28,9 @@
 #include "event/timeout.h"
 #include "event/callback.h"
 
-#define STACKSIZE       THREAD_STACKSIZE_DEFAULT
-#define PRIO            (THREAD_PRIORITY_MAIN - 1)
+#define STACKSIZE               THREAD_STACKSIZE_DEFAULT
+#define PRIO                    (THREAD_PRIORITY_MAIN - 1)
+#define DELAYED_QUEUES_NUMOF    2
 
 static char stack[STACKSIZE];
 
@@ -42,16 +43,18 @@ static void timed_callback(void *arg);
 static void forbidden_callback(void *arg);
 static void delayed_callback1(event_t *arg);
 static void delayed_callback2(event_t *arg);
+static void delayed_callback3(event_t *arg);
 
 static event_t event = { .handler = callback };
 static event_t event2 = { .handler = callback };
 static event_t delayed_event1 = { .handler = delayed_callback1 };
 static event_t delayed_event2 = { .handler = delayed_callback2 };
+static event_t delayed_event3 = { .handler = delayed_callback3 };
 
 static void callback(event_t *arg)
 {
     order++;
-    expect(order == 3);
+    expect(order == 4);
     expect(arg == &event);
     printf("triggered 0x%08x\n", (unsigned)arg);
 }
@@ -68,7 +71,7 @@ static event_callback_t noevent_callback = EVENT_CALLBACK_INIT(forbidden_callbac
 static void custom_callback(event_t *event)
 {
     order++;
-    expect(order == 4);
+    expect(order == 5);
     expect(event == (event_t *)&custom_event);
     custom_event_t *custom_event = (custom_event_t *)event;
     printf("triggered custom event with text: \"%s\"\n", custom_event->text);
@@ -77,7 +80,7 @@ static void custom_callback(event_t *event)
 static void timed_callback(void *arg)
 {
     order++;
-    expect(order == 5);
+    expect(order == 6);
     expect(arg == event_callback.arg);
     uint32_t now = xtimer_now_usec();
     expect((now - before >= 100000LU));
@@ -99,7 +102,7 @@ static void forbidden_callback(void *arg)
 static void delayed_callback1(event_t *arg)
 {
     order++;
-    expect(order == 1);
+    expect(order == 2);
     expect(arg == &delayed_event1);
     printf("triggered delayed event %p\n", (void *)arg);
 }
@@ -107,19 +110,29 @@ static void delayed_callback1(event_t *arg)
 static void delayed_callback2(event_t *arg)
 {
     order++;
-    expect(order == 2);
+    expect(order == 3);
     expect(arg == &delayed_event2);
     printf("triggered delayed event %p\n", (void *)arg);
 }
 
+static void delayed_callback3(event_t *arg)
+{
+    order++;
+    expect(order == 1);
+    expect(arg == &delayed_event3);
+    printf("triggered delayed event %p\n", (void *)arg);
+}
+
 static void *claiming_thread(void *arg)
 {
-    event_queue_t *dq = (event_queue_t *)arg;
+    event_queue_t *dqs = arg;
 
-    printf("claiming event queue %p\n", (void *)dq);
-    event_queue_claim(dq);
-    printf("launching event queue %p\n", (void *)dq);
-    event_loop(dq);
+    printf("claiming event queues %p\n", (void *)dqs);
+    for (size_t i = 0; i < DELAYED_QUEUES_NUMOF; i++) {
+        event_queue_claim(&dqs[i]);
+    }
+    printf("launching event queue for queues %p\n", (void *)dqs);
+    event_loop_multi(dqs, DELAYED_QUEUES_NUMOF);
 
     return NULL;
 }
@@ -129,17 +142,22 @@ int main(void)
     puts("[START] event test application.\n");
 
     /* test creation of delayed claiming of a detached event queue */
-    event_queue_t dq = EVENT_QUEUE_INIT_DETACHED;
-    printf("initializing detached event queue %p\n", (void *)&dq);
-    event_queue_init_detached(&dq);
+    event_queue_t dqs[DELAYED_QUEUES_NUMOF] = {
+        EVENT_QUEUE_INIT_DETACHED, EVENT_QUEUE_INIT_DETACHED
+    };
+    printf("initializing detached event queues %p\n", (void *)dqs);
+    event_queue_init_detached(&dqs[0]);
+    event_queue_init_detached(&dqs[1]);
 
-    printf("posting %p\n", (void *)&delayed_event1);
-    event_post(&dq, &delayed_event1);
-    printf("posting %p\n", (void *)&delayed_event2);
-    event_post(&dq, &delayed_event2);
+    printf("posting %p to delayed queue at index 1\n", (void *)&delayed_event1);
+    event_post(&dqs[1], &delayed_event1);
+    printf("posting %p to delayed queue at index 1\n", (void *)&delayed_event2);
+    event_post(&dqs[1], &delayed_event2);
+    printf("posting %p to delayed queue at index 0\n", (void *)&delayed_event3);
+    event_post(&dqs[0], &delayed_event3);
 
-    printf("running thread that will claim event queue %p\n", (void *)&dq);
-    thread_create(stack, sizeof(stack), PRIO, 0, claiming_thread, &dq, "ct");
+    printf("running thread that will claim event queues %p\n", (void *)&dqs);
+    thread_create(stack, sizeof(stack), PRIO, 0, claiming_thread, dqs, "ct");
 
     /* test posting different kind of events in order to a statically
      * initialized queue */