diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index e69add7394e60f..8680f51f2a4d22 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -119,7 +119,10 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
     });
     if (print) {
       const { log } = require('internal/console/global');
-      log(result);
+
+      process.on('exit', async () => {
+        log(await result);
+      });
     }
 
     if (origModule !== undefined)
diff --git a/test/parallel/test-cli-print-promise.mjs b/test/parallel/test-cli-print-promise.mjs
index 3f95630693035e..25d22579658319 100644
--- a/test/parallel/test-cli-print-promise.mjs
+++ b/test/parallel/test-cli-print-promise.mjs
@@ -15,7 +15,7 @@ describe('--print with a promise', { concurrency: true }, () => {
       code: 0,
       signal: null,
       stderr: '',
-      stdout: 'Promise { 42 }\n',
+      stdout: '42\n',
     });
   });
 
@@ -29,65 +29,92 @@ describe('--print with a promise', { concurrency: true }, () => {
       code: 0,
       signal: null,
       stderr: '',
-      stdout: 'Promise { <pending> }\n',
+      stdout: '42\n',
     });
   });
 
-  it('should handle promise that never settles', async () => {
+  it('should error with unhandled rejected promises', async () => {
     const result = await spawnPromisified(execPath, [
       '--print',
-      'new Promise(()=>{})',
+      'Promise.reject(1)',
     ]);
 
-    assert.deepStrictEqual(result, {
-      code: 0,
-      signal: null,
-      stderr: '',
-      stdout: 'Promise { <pending> }\n',
-    });
+    assert.strictEqual(result.code, 1);
+    assert.strictEqual(result.signal, null);
+    assert.strictEqual(result.stdout, '');
+    assert.ok(result.stderr.includes('ERR_UNHANDLED_REJECTION'), 'Not found ERR_UNHANDLED_REJECTION');
   });
 
-  it('should output something if process exits before promise settles', async () => {
+  it('should error when throw inside fn', async () => {
     const result = await spawnPromisified(execPath, [
       '--print',
-      'setTimeout(process.exit,100, 0);timers.promises.setTimeout(200)',
+      'Promise.resolve().then(()=>{throw new Error(10)})',
     ]);
 
-    assert.deepStrictEqual(result, {
-      code: 0,
-      signal: null,
-      stderr: '',
-      stdout: 'Promise { <pending> }\n',
-    });
+    assert.strictEqual(result.code, 1);
+    assert.strictEqual(result.signal, null);
+    assert.strictEqual(result.stdout, '');
+    assert.ok(result.stderr.includes('throw new Error(10)'), `Found: ${result.stderr}`);
+    assert.ok(result.stderr.includes('Error: 10'), `Found: ${result.stderr}`);
   });
 
-  it('should handle rejected promises', async () => {
+  it('should handle promise that never settles', async () => {
     const result = await spawnPromisified(execPath, [
-      '--unhandled-rejections=none',
       '--print',
-      'Promise.reject(1)',
+      'new Promise(()=>{})',
     ]);
 
     assert.deepStrictEqual(result, {
       code: 0,
       signal: null,
       stderr: '',
-      stdout: 'Promise { <rejected> 1 }\n',
+      stdout: '',
     });
   });
 
-  it('should handle promises that reject after one tick', async () => {
+  it('should output something if process exits before promise settles', async () => {
     const result = await spawnPromisified(execPath, [
-      '--unhandled-rejections=none',
       '--print',
-      'Promise.resolve().then(()=>Promise.reject(1))',
+      'setTimeout(process.exit,100, 0);timers.promises.setTimeout(200)',
     ]);
 
     assert.deepStrictEqual(result, {
       code: 0,
       signal: null,
       stderr: '',
-      stdout: 'Promise { <pending> }\n',
+      stdout: '',
+    });
+  });
+
+  describe('when under unhandled-rejections=none', () => {
+    it('should handle rejected promises', async () => {
+      const result = await spawnPromisified(execPath, [
+        '--unhandled-rejections=none',
+        '--print',
+        'Promise.reject(1)',
+      ]);
+
+      assert.deepStrictEqual(result, {
+        code: 0,
+        signal: null,
+        stderr: '',
+        stdout: '',
+      });
+    });
+
+    it('should handle promises that reject after one tick', async () => {
+      const result = await spawnPromisified(execPath, [
+        '--unhandled-rejections=none',
+        '--print',
+        'Promise.resolve().then(()=>Promise.reject(1))',
+      ]);
+
+      assert.deepStrictEqual(result, {
+        code: 0,
+        signal: null,
+        stderr: '',
+        stdout: '',
+      });
     });
   });
 });