diff --git a/packages/core/src/__tests__/utils.unit.spec.ts b/packages/core/src/__tests__/utils.unit.spec.ts
index 1bca63dc78..4db6f117ec 100644
--- a/packages/core/src/__tests__/utils.unit.spec.ts
+++ b/packages/core/src/__tests__/utils.unit.spec.ts
@@ -103,6 +103,15 @@ describe('utils', () => {
       ).resolves.toEqual(['a', 'b', 'c']);
     });
 
+    test('promiseAllAtOnce: keep ordering', async () => {
+      const data = [100, 50, 10];
+      const promiser = async (sleepInMs: number) => {
+        await sleepPromise(sleepInMs);
+        return sleepInMs;
+      };
+      await expect(promiseAllAtOnce(data, promiser)).resolves.toEqual(data);
+    });
+
     test('promiseEachInSequence', async () => {
       expect(
         await promiseEachInSequence([], (input) => Promise.resolve(input))
diff --git a/packages/core/src/utils.ts b/packages/core/src/utils.ts
index 7df0a422a4..c49b45ff78 100644
--- a/packages/core/src/utils.ts
+++ b/packages/core/src/utils.ts
@@ -108,20 +108,35 @@ export async function promiseAllAtOnce<RequestType, ResponseType>(
   const responses: ResponseType[] = [];
   const errors: (Error | CogniteError)[] = [];
 
-  const promises = inputs.map((input) => promiser(input));
+  const promises = inputs.map(promiser);
 
-  const wrappedPromises = promises.map((promise, index) =>
-    promise
-      .then((result) => {
-        succeded.push(inputs[index]);
-        responses.push(result);
-      })
-      .catch((error) => {
-        failed.push(inputs[index]);
-        errors.push(error);
+  type SingleResult = {
+    succeded?: RequestType;
+    response?: ResponseType;
+    failed?: RequestType;
+    error?: Error | CogniteError;
+  };
+
+  const wrappedPromises: Promise<SingleResult>[] = promises.map(
+    (promise, index) =>
+      new Promise<SingleResult>((resolve) => {
+        promise
+          .then((result) => {
+            resolve({ succeded: inputs[index], response: result });
+          })
+          .catch((error) => {
+            resolve({ failed: inputs[index], error });
+          });
       })
   );
-  await Promise.all(wrappedPromises);
+
+  const results = await Promise.all(wrappedPromises);
+  results.forEach((res) => {
+    failed.push(...(res.failed ? [res.failed] : []));
+    succeded.push(...(res.succeded ? [res.succeded] : []));
+    responses.push(...(res.response ? [res.response] : []));
+    errors.push(...(res.error ? [res.error] : []));
+  });
   if (failed.length) {
     throw {
       succeded,
diff --git a/packages/stable/src/__tests__/api/events.int.spec.ts b/packages/stable/src/__tests__/api/events.int.spec.ts
index daebf387c8..23ff43a743 100644
--- a/packages/stable/src/__tests__/api/events.int.spec.ts
+++ b/packages/stable/src/__tests__/api/events.int.spec.ts
@@ -129,15 +129,16 @@ describe('Events integration test', () => {
     test('descending', async () => {
       await client.events.list({ sort: { endTime: SortOrder.DESC } });
     });
-    test('multiple props not supported', async () => {
+    test('multiple props supported', async () => {
       await expect(
         client.events.list({
+          limit: 1,
           sort: {
             startTime: 'asc',
             lastUpdatedTime: 'desc',
           },
         })
-      ).rejects.toThrowError();
+      ).resolves.toBeDefined();
     });
   });