diff --git a/configure b/configure
index c04118e9832b0c..7d13d3c982fc00 100755
--- a/configure
+++ b/configure
@@ -1140,7 +1140,8 @@ def configure_v8(o):
   o['variables']['v8_no_strict_aliasing'] = 1  # Work around compiler bugs.
   o['variables']['v8_optimized_debug'] = 0  # Compile with -O0 in debug builds.
   o['variables']['v8_random_seed'] = 0  # Use a random seed for hash tables.
-  o['variables']['v8_promise_internal_field_count'] = 1 # Add internal field to promises for async hooks.
+  # Add internal field to promises for async hooks and unhandled rejections.
+  o['variables']['v8_promise_internal_field_count'] = 2
   o['variables']['v8_use_snapshot'] = 'false' if options.without_snapshot else 'true'
   o['variables']['v8_trace_maps'] = 1 if options.trace_maps else 0
   o['variables']['node_use_v8_platform'] = b(not options.without_v8_platform)
diff --git a/deps/v8/gypfiles/features.gypi b/deps/v8/gypfiles/features.gypi
index 69ff763be04ab5..2388ba2729cf3e 100644
--- a/deps/v8/gypfiles/features.gypi
+++ b/deps/v8/gypfiles/features.gypi
@@ -105,7 +105,7 @@
         'defines': ['ENABLE_DISASSEMBLER',],
       }],
       ['v8_promise_internal_field_count!=0', {
-        'defines': ['V8_PROMISE_INTERNAL_FIELD_COUNT','v8_promise_internal_field_count'],
+        'defines': ['V8_PROMISE_INTERNAL_FIELD_COUNT=<(v8_promise_internal_field_count)'],
       }],
       ['v8_enable_gdbjit==1', {
         'defines': ['ENABLE_GDB_JIT_INTERFACE',],
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 637c1cd9050557..53ed119e721d41 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -277,6 +277,33 @@ Write process warnings to the given file instead of printing to stderr. The
 file will be created if it does not exist, and will be appended to if it does.
 If an error occurs while attempting to write the warning to the file, the
 warning will be written to stderr instead.
+
+### `--unhandled-rejections=mode`
+<!-- YAML
+added: REPLACEME
+-->
+
+See below ..
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 ### `--throw-deprecation`
 <!-- YAML
@@ -625,6 +652,36 @@ Path to the file used to store the persistent REPL history. The default path is
 `~/.node_repl_history`, which is overridden by this variable. Setting the value
 to an empty string (`''` or `' '`) disables persistent REPL history.
 
+### `NODE_UNHANDLED_REJECTION=state`
+<!-- YAML
+added: REPLACEME
+-->
+
+Setting this environment variable allows fine grained control over the behavior
+of unhandled rejections. This may be set to either one of `SILENT`, `WARN`,
+`ERROR_ON_GC`, `ERROR` or `STRICT` while the default behavior without using the
+environment variable is the same as `WARN`. `WARN` reflects the
+[`unhandledRejection hook`][]. The [`unhandledRejection hook`][] functionality
+is not influenced by any of these options.
+
+Setting the environment variable to `SILENT` prevents unhandled rejection
+warnings from being logged, even if no [`unhandledRejection hook`][] is
+attached.
+
+If set to `ERROR_ON_GC` unhandled rejections that are [garbage collected][] are
+raised as uncaught exceptions.
+
+If set to `ERROR` all rejections that are not handled after a single
+`nextTick()` has passed are raised as uncaught exception.
+
+If set to `STRICT` all rejections that are not handled synchronous are raised as
+uncaught exception.
+
+Any rejection that is raised as exception can be caught by the
+[`uncaughtException hook`][]. Handling promises can be done lazily by adding a
+catch handler to the promise chain after the promise was already potentially
+rejected.
+
 ### `OPENSSL_CONF=file`
 <!-- YAML
 added: v6.11.0
@@ -689,9 +746,12 @@ greater than `4` (its current default value). For more information, see the
 [`Buffer`]: buffer.html#buffer_class_buffer
 [`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
 [`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
+[`uncaughtException hook`]: process.html#process_event_uncaughtexception
+[`unhandledRejection hook`]: process.html#process_event_unhandledrejection
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
 [REPL]: repl.html
 [debugger]: debugger.html
 [emit_warning]: process.html#process_process_emitwarning_warning_type_code_ctor
 [experimental ECMAScript Module]: esm.html#esm_loader_hooks
+[garbage collected]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management#Garbage_collection
 [libuv threadpool documentation]: http://docs.libuv.org/en/latest/threadpool.html
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 10ffa49f4d5207..1b739c3dcb4262 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -1057,16 +1057,16 @@ future release.
 [`Buffer.isBuffer()`]: buffer.html#buffer_class_method_buffer_isbuffer_obj
 [`Cipher`]: crypto.html#crypto_class_cipher
 [`Decipher`]: crypto.html#crypto_class_decipher
-[`assert`]: assert.html
-[`clearInterval()`]: timers.html#timers_clearinterval_timeout
-[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
 [`EventEmitter.listenerCount(emitter, eventName)`]: events.html#events_eventemitter_listenercount_emitter_eventname
 [`Server.connections`]: net.html#net_server_connections
 [`Server.getConnections()`]: net.html#net_server_getconnections_callback
 [`Server.listen({fd: <number>})`]: net.html#net_server_listen_handle_backlog_callback
 [`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
+[`assert`]: assert.html
 [`asyncResource.runInAsyncScope()`]: async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args
 [`child_process`]: child_process.html
+[`clearInterval()`]: timers.html#timers_clearinterval_timeout
+[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
 [`console.error()`]: console.html#console_console_error_data_args
 [`console.log()`]: console.html#console_console_log_data_args
 [`crypto.createCipher()`]: crypto.html#crypto_crypto_createcipher_algorithm_password_options
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 34d85d0ceb7934..e8dad8d264732f 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1158,6 +1158,12 @@ Invalid characters were detected in headers.
 A cursor on a given stream cannot be moved to a specified row without a
 specified column.
 
+<a id="ERR_INVALID_ENV_VALUE"></a>
+### ERR_INVALID_ENV_VALUE
+
+An environment variable value which is unrecognized. Please consult the
+documentation and make sure to pass in valid values.
+
 <a id="ERR_INVALID_FD"></a>
 ### ERR_INVALID_FD
 
diff --git a/doc/api/process.md b/doc/api/process.md
index 34f7eb6505a1f0..f47d327dee4e50 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -147,8 +147,17 @@ most convenient for scripts).
 ### Event: 'uncaughtException'
 <!-- YAML
 added: v0.1.18
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/20097
+    description: Added the `errorOrigin` argument.
 -->
 
+* `err` {Error} The uncaught exception.
+* `errorOrigin` {string} Indicates if the exception originates from an
+  unhandled rejection or from synchronous errors. Can either be `'FROM_PROMISE'`
+  or `'FROM_ERROR'`.
+
 The `'uncaughtException'` event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
 handles such exceptions by printing the stack trace to `stderr` and exiting
@@ -159,12 +168,13 @@ behavior. You may also change the [`process.exitCode`][] in
 provided exit code, otherwise in the presence of such handler the process will
 exit with 0.
 
-The listener function is called with the `Error` object passed as the only
-argument.
-
 ```js
-process.on('uncaughtException', (err) => {
-  fs.writeSync(1, `Caught exception: ${err}\n`);
+process.on('uncaughtException', (err, errorOrigin) => {
+  fs.writeSync(
+    1,
+    `Caught exception: ${err}\n` +
+    `Exception originated from unhandled rejection: ${errorOrigin}`
+  );
 });
 
 setTimeout(() => {
@@ -216,6 +226,10 @@ changes:
                  a process warning.
 -->
 
+* `reason` {Error|any} The object with which the promise was rejected
+  (typically an [`Error`][] object).
+* `promise` {Promise} The rejected promise.
+
 The `'unhandledRejection'` event is emitted whenever a `Promise` is rejected and
 no error handler is attached to the promise within a turn of the event loop.
 When programming with Promises, exceptions are encapsulated as "rejected
@@ -224,21 +238,15 @@ are propagated through a `Promise` chain. The `'unhandledRejection'` event is
 useful for detecting and keeping track of promises that were rejected whose
 rejections have not yet been handled.
 
-The listener function is called with the following arguments:
-
-* `reason` {Error|any} The object with which the promise was rejected
-  (typically an [`Error`][] object).
-* `p` the `Promise` that was rejected.
-
 ```js
-process.on('unhandledRejection', (reason, p) => {
-  console.log('Unhandled Rejection at:', p, 'reason:', reason);
-  // application specific logging, throwing an error, or other logic here
+process.on('unhandledRejection', (reason, promise) => {
+  console.log('Unhandled Rejection at:', promise, 'reason:', reason);
+  // Application specific logging, throwing an error, or other logic here
 });
 
 somePromise.then((res) => {
-  return reportToUser(JSON.pasre(res)); // note the typo (`pasre`)
-}); // no `.catch()` or `.then()`
+  return reportToUser(JSON.pasre(res)); // Note the typo (`pasre`)
+}); // No `.catch()` or `.then()`
 ```
 
 The following will also trigger the `'unhandledRejection'` event to be
@@ -251,7 +259,7 @@ function SomeResource() {
 }
 
 const resource = new SomeResource();
-// no .catch or .then on resource.loaded for at least a turn
+// No .catch or .then on resource.loaded for at least a turn
 ```
 
 In this example case, it is possible to track the rejection as a developer error
@@ -259,7 +267,7 @@ as would typically be the case for other `'unhandledRejection'` events. To
 address such failures, a non-operational
 [`.catch(() => { })`][`promise.catch()`] handler may be attached to
 `resource.loaded`, which would prevent the `'unhandledRejection'` event from
-being emitted. Alternatively, the [`'rejectionHandled'`][] event may be used.
+being emitted.
 
 ### Event: 'warning'
 <!-- YAML
@@ -2089,7 +2097,6 @@ cases:
 [`'exit'`]: #process_event_exit
 [`'finish'`]: stream.html#stream_event_finish
 [`'message'`]: child_process.html#child_process_event_message
-[`'rejectionHandled'`]: #process_event_rejectionhandled
 [`'uncaughtException'`]: #process_event_uncaughtexception
 [`ChildProcess.disconnect()`]: child_process.html#child_process_subprocess_disconnect
 [`subprocess.kill()`]: child_process.html#child_process_subprocess_kill_signal
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 069c8bc9975fa1..e27bf220d98751 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -518,14 +518,23 @@
       emitAfter
     } = NativeModule.require('internal/async_hooks');
 
-    process._fatalException = function(er) {
+    const {
+      unhandledState,
+      states
+    } = NativeModule.require('internal/process/promises');
+
+    process._fatalException = function(er, fromPromise = false) {
+      if (fromPromise && unhandledState() <= states.WARN) {
+        return true;
+      }
       // It's possible that defaultTriggerAsyncId was set for a constructor
       // call that threw and was never cleared. So clear it now.
       clearDefaultTriggerAsyncId();
 
+      const from = fromPromise ? 'FROM_PROMISE' : 'FROM_ERROR';
       if (exceptionHandlerState.captureFn !== null) {
         exceptionHandlerState.captureFn(er);
-      } else if (!process.emit('uncaughtException', er)) {
+      } else if (!process.emit('uncaughtException', er, from)) {
         // If someone handled it, then great.  otherwise, die in C++ land
         // since that means that we'll exit the process, emit the 'exit' event.
         try {
@@ -541,7 +550,7 @@
           const { kExpandStackSymbol } = NativeModule.require('internal/util');
           if (typeof er[kExpandStackSymbol] === 'function')
             er[kExpandStackSymbol]();
-        } catch (er) {}
+        } catch {}
         return false;
       }
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index cc1e84639eb0eb..7d8d6d090c5fc1 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -665,6 +665,8 @@ E('ERR_INVALID_CHAR',
   }, TypeError);
 E('ERR_INVALID_CURSOR_POS',
   'Cannot set cursor row without setting its column', TypeError);
+E('ERR_INVALID_ENV_VALUE',
+  'The value "%s" for environment variable %s is invalid.', TypeError);
 E('ERR_INVALID_FD',
   '"fd" must be a positive integer: %s', RangeError);
 E('ERR_INVALID_FD_TYPE', 'Unsupported fd type: %s', TypeError);
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index f54f34b9ae92f4..617cafac25d5da 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -1,15 +1,50 @@
 'use strict';
 
+const { ERR_INVALID_ENV_VALUE } = require('internal/errors').codes;
+
+// TODO: Do not add stack traces to the here created errors as they are
+// meaningless. That improves the performance in error cases.
+// TODO: Make the error names non-enumerable.
+
 const { safeToString } = process.binding('util');
 
 const maybeUnhandledPromises = new WeakMap();
-const pendingUnhandledRejections = [];
-const asyncHandledRejections = [];
+
+let pendingUnhandledRejections = [];
+let asyncHandledRejections = [];
 let lastPromiseId = 0;
 
-exports.setup = setupPromises;
+const kFromPromise = true;
+const kFromError = false;
+const states = {
+  SILENT: 0,
+  WARN: 1,
+  ERROR_ON_GC: 2,
+  ERROR: 3,
+};
+
+function unhandledState() {
+  let env = process.env.NODE_UNHANDLED_REJECTION;
+  if (env) {
+    env = env.toUpperCase();
+    if (states[env] !== undefined) {
+      return states[env];
+    }
+    // Raise an exception to indicate the faulty environment variable value.
+    const err = new ERR_INVALID_ENV_VALUE(env, 'NODE_UNHANDLED_REJECTION');
+    fatalException(err, kFromError);
+    // Remove the faulty environment variable to make sure everything works fine
+    // afterwards if the error is handled by the user and the user decided to
+    // continue running the application.
+    delete process.env.NODE_UNHANDLED_REJECTION;
+  }
+  return states.WARN;
+}
 
 function setupPromises(_setupPromises) {
+  // Verify while startup that a possible environment variable has a valid
+  // value.
+  unhandledState();
   _setupPromises(unhandledRejection, handledRejection);
   return emitPromiseRejectionWarnings;
 }
@@ -20,6 +55,7 @@ function unhandledRejection(promise, reason) {
     uid: ++lastPromiseId,
     warned: false
   });
+  // This causes the promise to be referenced at least for one tick.
   pendingUnhandledRejections.push(promise);
   return true;
 }
@@ -51,10 +87,9 @@ function emitWarning(uid, reason) {
     } else {
       process.emitWarning(safeToString(reason), unhandledRejectionErrName);
     }
-  } catch (e) {
-    // ignored
-  }
-
+  } catch {}
+  // TODO: Reword the error message. It partially duplicates the error name.
+  // TODO: Add a code properly to the error.
   // eslint-disable-next-line no-restricted-syntax
   const warning = new Error(
     'Unhandled promise rejection. This error originated either by ' +
@@ -67,11 +102,13 @@ function emitWarning(uid, reason) {
     if (reason instanceof Error) {
       warning.stack = reason.stack;
     }
-  } catch (err) {
-    // ignored
-  }
+  } catch {}
   process.emitWarning(warning);
-  emitDeprecationWarning();
+  // Only emit the deprecation notice in case the user did not opt into using
+  // the environment variable / flag.
+  if (!process.env.NODE_UNHANDLED_REJECTION) {
+    emitDeprecationWarning();
+  }
 }
 
 let deprecationWarned = false;
@@ -91,23 +128,82 @@ function emitPromiseRejectionWarnings() {
     const { promise, warning } = asyncHandledRejections.shift();
     if (!process.emit('rejectionHandled', promise)) {
       process.emitWarning(warning);
+    } else {
+      // Stop the loop early.
+      asyncHandledRejections = [];
     }
   }
 
-  let hadListeners = false;
   let len = pendingUnhandledRejections.length;
   while (len--) {
     const promise = pendingUnhandledRejections.shift();
     const promiseInfo = maybeUnhandledPromises.get(promise);
-    if (promiseInfo !== undefined) {
-      promiseInfo.warned = true;
-      const { reason, uid } = promiseInfo;
-      if (!process.emit('unhandledRejection', reason, promise)) {
+    if (promiseInfo === undefined) {
+      continue;
+    }
+    promiseInfo.warned = true;
+    const { reason, uid } = promiseInfo;
+    const state = unhandledState();
+    if (state === states.ERROR) {
+      fatalException(reason, kFromPromise);
+    }
+    if (!process.emit('unhandledRejection', reason, promise)) {
+      if (state === states.WARN || state === states.ERROR_ON_GC) {
         emitWarning(uid, reason);
-      } else {
-        hadListeners = true;
+      // Stop the loop as soon as possible. Since the handler might have been
+      // attached in the beginning and then removed again and a new unhandled
+      // rejection might have been added at that former state, only stop if no
+      // new rejections were added.
+      } else if (len === pendingUnhandledRejections.length &&
+          state < states.ERROR) {
+        pendingUnhandledRejections = [];
+        break;
       }
     }
   }
-  return hadListeners || pendingUnhandledRejections.length !== 0;
+  return pendingUnhandledRejections.length !== 0;
+}
+
+function createError(name, message) {
+  // Reset the stack to prevent any overhead.
+  const tmp = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
+  // eslint-disable-next-line no-restricted-syntax
+  const err = new Error(message);
+  Error.stackTraceLimit = tmp;
+  Object.defineProperty(err, 'name', {
+    value: name,
+    writable: true,
+    configurable: true,
+  });
+  return err;
+}
+
+function fatalException(reason, fromPromise) {
+  let err;
+  if (reason instanceof Error) {
+    err = reason;
+  } else {
+    err = createError(
+      'UnhandledPromiseRejection',
+      'This error originated either by ' +
+        'throwing inside of an async function without a catch block, ' +
+        'or by rejecting a promise which was not handled with .catch().' +
+        ` The promise rejected with the reason "${safeToString(reason)}".`
+    );
+  }
+  // Throw an error if the user did not handle the exception.
+  if (!process._fatalException(err, fromPromise)) {
+    process._rawDebug(err.stack);
+    if (process.binding('config').shouldAbortOnUncaughtException) {
+      process.abort();
+    }
+    process.exit(1);
+  }
 }
+
+module.exports = {
+  setup: setupPromises,
+  unhandledState,
+  states,
+};
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 720f89c011801e..b2738aa80d57c1 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -9,17 +9,27 @@ namespace node {
 
 using v8::Array;
 using v8::Context;
+using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
+using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::Message;
 using v8::Object;
 using v8::Promise;
 using v8::PromiseRejectEvent;
 using v8::PromiseRejectMessage;
 using v8::String;
 using v8::Value;
+using v8::WeakCallbackInfo;
+using v8::WeakCallbackType;
+
+static constexpr bool kFromPromise = true;
+
+// The internal field 0 is used by PromiseHook() in async-wrap.cc.
+static constexpr int kUnhandledPromiseField = 1;
 
 void SetupProcessObject(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -58,6 +68,23 @@ void SetupNextTick(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(ret);
 }
 
+void WeakCallback(
+    const v8::WeakCallbackInfo<Persistent<Promise> >& data) {
+  Environment* env = Environment::GetCurrent(data.GetIsolate());
+  Persistent<Promise>* p = data.GetParameter();
+  p->ClearWeak();
+
+  env->SetImmediate([](Environment* env, void* data) {
+    HandleScope handle_scope(env->isolate());
+    Persistent<Promise>* p = static_cast<Persistent<Promise>*>(data);
+    Local<Promise> promise = p->Get(env->isolate());
+    Local<Value> err = promise->Result();
+    Local<Message> message = Exception::CreateMessage(env->isolate(), err);
+    InternalFatalException(env->isolate(), err, message, kFromPromise);
+    delete p;
+  }, p);
+}
+
 void PromiseRejectCallback(PromiseRejectMessage message) {
   static std::atomic<uint64_t> unhandledRejections{0};
   static std::atomic<uint64_t> rejectionsHandledAfter{0};
@@ -72,13 +99,27 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
 
   if (event == v8::kPromiseRejectWithNoHandler) {
     callback = env->promise_reject_unhandled_function();
-    value = message.GetValue();
 
+    // Call fatalException in case the unhandled promise is garbage collected
+    // without being handled later on.
+    Persistent<Promise>* p = new Persistent<Promise>(env->isolate(), promise);
+    p->SetWeak(p, WeakCallback, WeakCallbackType::kFinalizer);
+    CHECK_EQ(promise->GetAlignedPointerFromInternalField(
+      kUnhandledPromiseField), nullptr);
+    promise->SetAlignedPointerInInternalField(kUnhandledPromiseField, p);
+
+    value = message.GetValue();
     if (value.IsEmpty())
       value = Undefined(isolate);
 
     unhandledRejections++;
   } else if (event == v8::kPromiseHandlerAddedAfterReject) {
+    Persistent<Promise>* p = static_cast<Persistent<Promise>*>(
+        promise->GetAlignedPointerFromInternalField(
+            kUnhandledPromiseField));
+    delete p;
+    promise->SetAlignedPointerInInternalField(
+      kUnhandledPromiseField, nullptr);
     callback = env->promise_reject_handled_function();
     value = Undefined(isolate);
 
@@ -98,7 +139,6 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
                                          Undefined(isolate),
                                          arraysize(args),
                                          args);
-
   if (!ret.IsEmpty() && ret.ToLocalChecked()->IsTrue())
     env->tick_info()->promise_rejections_toggle_on();
 }
diff --git a/src/node.cc b/src/node.cc
index 3597571cdffd4c..d6b50291c90b00 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -175,6 +175,8 @@ static node_module* modlist_addon;
 // TODO(addaleax): This should not be global.
 static bool abort_on_uncaught_exception = false;
 
+static constexpr bool kFromError = false;
+
 // Bit flag used to track security reverts (see node_revert.h)
 unsigned int reverted = 0;
 
@@ -1466,7 +1468,7 @@ static void OnFatalError(const char* location, const char* message) {
 
 NO_RETURN void FatalError(const char* location, const char* message) {
   OnFatalError(location, message);
-  // to suppress compiler warning
+  // To suppress compiler warning.
   ABORT();
 }
 
@@ -1479,10 +1481,16 @@ FatalTryCatch::~FatalTryCatch() {
   }
 }
 
-
 void FatalException(Isolate* isolate,
                     Local<Value> error,
                     Local<Message> message) {
+  InternalFatalException(isolate, error, message, kFromError);
+}
+
+void InternalFatalException(Isolate* isolate,
+                            Local<Value> error,
+                            Local<Message> message,
+                            bool from_promise) {
   HandleScope scope(isolate);
 
   Environment* env = Environment::GetCurrent(isolate);
@@ -1493,7 +1501,7 @@ void FatalException(Isolate* isolate,
 
   if (!fatal_exception_function->IsFunction()) {
     // Failed before the process._fatalException function was added!
-    // this is probably pretty bad.  Nothing to do but report and exit.
+    // this is probably pretty bad. Nothing to do but report and exit.
     ReportException(env, error, message);
     exit(6);
   } else {
@@ -1502,10 +1510,13 @@ void FatalException(Isolate* isolate,
     // Do not call FatalException when _fatalException handler throws
     fatal_try_catch.SetVerbose(false);
 
+    Local<Value> argv[2] = { error,
+                             Boolean::New(env->isolate(), from_promise) };
+
     // This will return true if the JS layer handled it, false otherwise
     Local<Value> caught =
         fatal_exception_function.As<Function>()
-            ->Call(process_object, 1, &error);
+            ->Call(process_object, arraysize(argv), argv);
 
     if (fatal_try_catch.HasTerminated())
       return;
@@ -1517,15 +1528,19 @@ void FatalException(Isolate* isolate,
     } else if (caught->IsFalse()) {
       ReportException(env, error, message);
 
-      // fatal_exception_function call before may have set a new exit code ->
-      // read it again, otherwise use default for uncaughtException 1
-      Local<String> exit_code = env->exit_code_string();
-      Local<Value> code;
-      if (!process_object->Get(env->context(), exit_code).ToLocal(&code) ||
-          !code->IsInt32()) {
-        exit(1);
+      if (abort_on_uncaught_exception) {
+        ABORT();
+      } else {
+        // Fatal_exception_function call before may have set a new exit code ->
+        // read it again, otherwise use default for uncaughtException 1
+        Local<String> exit_code = env->exit_code_string();
+        Local<Value> code;
+        if (!process_object->Get(env->context(), exit_code).ToLocal(&code) ||
+            !code->IsInt32()) {
+          exit(1);
+        }
+        exit(code.As<v8::Int32>()->Value());
       }
-      exit(code.As<v8::Int32>()->Value());
     }
   }
 }
diff --git a/src/node_internals.h b/src/node_internals.h
index edfc00e53f13a7..298fe9022b040d 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -224,6 +224,10 @@ void FatalException(v8::Isolate* isolate,
                     v8::Local<v8::Value> error,
                     v8::Local<v8::Message> message);
 
+void InternalFatalException(v8::Isolate* isolate,
+                            v8::Local<v8::Value> error,
+                            v8::Local<v8::Message> message,
+                            bool from_promise);
 
 void SignalExit(int signo);
 #ifdef __POSIX__
diff --git a/test/message/promise_always_throw_unhandled.js b/test/message/promise_always_throw_unhandled.js
new file mode 100644
index 00000000000000..44921afbd7763e
--- /dev/null
+++ b/test/message/promise_always_throw_unhandled.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+
+// Check that the process will exit on the first unhandled rejection in case the
+// environment variable is set to `'ERROR'`.
+
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+
+const ref1 = new Promise(() => {
+  throw new Error('One');
+});
+
+const ref2 = Promise.reject(new Error('Two'));
+
+// Keep the event loop alive to actually detect the unhandled rejection.
+setTimeout(() => console.log(ref1, ref2), 1000);
diff --git a/test/message/promise_always_throw_unhandled.out b/test/message/promise_always_throw_unhandled.out
new file mode 100644
index 00000000000000..2b51c02b8f76ba
--- /dev/null
+++ b/test/message/promise_always_throw_unhandled.out
@@ -0,0 +1,11 @@
+Error: One
+    at Promise (*promise_always_throw_unhandled.js:*:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_always_throw_unhandled.js:*:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
diff --git a/test/message/promise_fast_reject.js b/test/message/promise_fast_reject.js
new file mode 100644
index 00000000000000..c901b735a74ebc
--- /dev/null
+++ b/test/message/promise_fast_reject.js
@@ -0,0 +1,18 @@
+'use strict';
+
+// Currently we keep a reference of unhandled rejections in JS and that prevents
+// the GC to collect these before the process exits naturally.
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+new Promise(function(res, rej) {
+  throw new Error('One');
+});
+
+Promise.reject(new Error('Two'));
+
+process.on('uncaughtException', common.mustNotCall());
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_fast_reject.out b/test/message/promise_fast_reject.out
new file mode 100644
index 00000000000000..9f566f70839f71
--- /dev/null
+++ b/test/message/promise_fast_reject.out
@@ -0,0 +1,24 @@
+(node:*) UnhandledPromiseRejectionWarning: Error: One
+    at *promise_fast_reject.js:*
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_fast_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
+(node:*) UnhandledPromiseRejectionWarning: Error: Two
+    at *promise_fast_reject.js:*
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 2)
+Exit code 0
diff --git a/test/message/promise_unhandled_caught.js b/test/message/promise_unhandled_caught.js
new file mode 100644
index 00000000000000..ff1637a75cacdc
--- /dev/null
+++ b/test/message/promise_unhandled_caught.js
@@ -0,0 +1,20 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+new Promise(function(res, rej) {
+  throw new Error('Fail');
+});
+
+setTimeout(() => {
+  global.gc();
+}, 1);
+
+process.on('uncaughtException', common.mustCall((err, fromPromise) => {
+  console.log(`Caught ${err.message}; From promise: ${fromPromise}`);
+}));
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_unhandled_caught.out b/test/message/promise_unhandled_caught.out
new file mode 100644
index 00000000000000..5f3f6130bb603c
--- /dev/null
+++ b/test/message/promise_unhandled_caught.out
@@ -0,0 +1,14 @@
+Caught Fail; From promise: FROM_PROMISE
+(node:*) UnhandledPromiseRejectionWarning: Error: Fail
+    at *promise_unhandled_caught.js:*
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_caught.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(node:*) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
+Exit code 0
diff --git a/test/message/promise_unhandled_reject.js b/test/message/promise_unhandled_reject.js
new file mode 100644
index 00000000000000..b6abe41aa18988
--- /dev/null
+++ b/test/message/promise_unhandled_reject.js
@@ -0,0 +1,55 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+// TODO: Remove when making this the default.
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR_ON_GC';
+
+// Verify that unhandled rejections cause `process.exit` to be called with exit
+// code 1 if they get garbage collected. Any promise that is handled later on
+// should not cause this.
+
+let p1 = new Promise(() => {
+  throw new Error('One');
+});
+
+// eslint-disable-next-line no-unused-vars
+let p2 = new Promise(() => {
+  throw new Error('Two');
+});
+
+const p3 = Promise.reject(new Error('Three'));
+
+global.gc();
+
+process.nextTick(() => {
+  console.log('First GC did not collect it.');
+  global.gc();
+  // Should not trigger an error.
+  p1.catch(() => {});
+  p1 = null;
+  setImmediate(() => {
+    console.log('Second GC did not collect it.');
+    setTimeout(() => {
+      // Should still trigger a warning.
+      p3.catch(() => {});
+      // Keep a hard reference to p2.
+      console.log(p2);
+    }, 1000);
+    global.gc();
+    setImmediate(() => {
+      console.log('Third GC did not collect it.');
+      // Free the reference and exit on GC
+      p2 = null;
+      // Trigger a fatal exception on setImmediate
+      global.gc();
+      setImmediate(() => {
+        console.log('Should not be reached');
+      });
+    });
+  });
+});
+
+process.on('unhandledRejection', common.mustCall(console.log, 2));
+
+process.on('exit', (code) => process._rawDebug(`Exit code ${code}`));
diff --git a/test/message/promise_unhandled_reject.out b/test/message/promise_unhandled_reject.out
new file mode 100644
index 00000000000000..5773fc142114f0
--- /dev/null
+++ b/test/message/promise_unhandled_reject.out
@@ -0,0 +1,61 @@
+First GC did not collect it.
+Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+  <rejected> Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+Error: Three
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+  <rejected> Error: Three
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+Second GC did not collect it.
+Third GC did not collect it.
+Exit code 1
+undefined:0
+
+
+
+Error: Two
+    at Promise (*promise_unhandled_reject.js:*)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (*promise_unhandled_reject.js:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
diff --git a/test/parallel/test-async-wrap-pop-id-during-load.js b/test/parallel/test-async-wrap-pop-id-during-load.js
index 31d2113eabc163..3e23596dfce596 100644
--- a/test/parallel/test-async-wrap-pop-id-during-load.js
+++ b/test/parallel/test-async-wrap-pop-id-during-load.js
@@ -18,8 +18,8 @@ const ret = spawnSync(
   process.execPath,
   ['--stack_size=75', __filename, 'async']
 );
-assert.strictEqual(ret.status, 0,
-                   `EXIT CODE: ${ret.status}, STDERR:\n${ret.stderr}`);
 const stderr = ret.stderr.toString('utf8', 0, 2048);
+assert.strictEqual(ret.status, 0,
+                   `EXIT CODE: ${ret.status}, STDERR:\n${stderr}`);
 assert.ok(!/async.*hook/i.test(stderr));
 assert.ok(stderr.includes('UnhandledPromiseRejectionWarning: Error'), stderr);
diff --git a/test/parallel/test-next-tick-errors.js b/test/parallel/test-next-tick-errors.js
index acb7c497278429..26fc6de235a6ef 100644
--- a/test/parallel/test-next-tick-errors.js
+++ b/test/parallel/test-next-tick-errors.js
@@ -61,7 +61,9 @@ testNextTickWith('str');
 testNextTickWith({});
 testNextTickWith([]);
 
-process.on('uncaughtException', function() {
+process.on('uncaughtException', function(err, errorOrigin) {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+
   if (!exceptionHandled) {
     exceptionHandled = true;
     order.push('B');
diff --git a/test/parallel/test-process-fatal-exception-tick.js b/test/parallel/test-process-fatal-exception-tick.js
index f22273e01c9db8..fbdef154fd80d8 100644
--- a/test/parallel/test-process-fatal-exception-tick.js
+++ b/test/parallel/test-process-fatal-exception-tick.js
@@ -12,9 +12,12 @@ if (!common.isMainThread)
 
 let stage = 0;
 
-process.once('uncaughtException', common.expectsError({
-  type: Error,
-  message: 'caughtException'
+process.once('uncaughtException', common.mustCall((err, errorOrigin) => {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+  common.expectsError({
+    type: Error,
+    message: 'caughtException'
+  })(err);
 }));
 
 setImmediate(() => {
diff --git a/test/parallel/test-promise-unhandled-error.js b/test/parallel/test-promise-unhandled-error.js
new file mode 100644
index 00000000000000..6c07c00ee6b34e
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-error.js
@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+
+process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+
+// Verify that unhandled rejections always trigger uncaught exceptions instead
+// of triggering unhandled rejections.
+
+const err1 = new Error('One');
+const err2 = new Error(
+  'This error originated either by throwing ' +
+  'inside of an async function without a catch block, or by rejecting a ' +
+  'promise which was not handled with .catch(). The promise rejected with the' +
+  ' reason "null".'
+);
+Object.defineProperty(err2, 'name', {
+  value: 'UnhandledPromiseRejection',
+  writable: true,
+  configurable: true
+});
+
+const errors = [err1, err2];
+const identical = [true, false];
+
+const ref = new Promise(() => {
+  throw err1;
+});
+// Explicitly reject `null`.
+Promise.reject(null);
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('unhandledRejection', common.mustCall(2));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+process.on('exit', assert.strictEqual.bind(null, 0));
+
+const timer = setTimeout(() => console.log(ref), 1000);
+
+const counter = new Countdown(2, () => {
+  clearTimeout(timer);
+});
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  counter.dec();
+  assert.strictEqual(origin, 'FROM_PROMISE', err);
+  const knownError = errors.shift();
+  assert.deepStrictEqual(err, knownError);
+  // Check if the errors are reference equal.
+  assert(identical.shift() ? err === knownError : err !== knownError);
+}, 2));
diff --git a/test/parallel/test-promise-unhandled-rejection-env.js b/test/parallel/test-promise-unhandled-rejection-env.js
new file mode 100644
index 00000000000000..f49759e0bf2660
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-rejection-env.js
@@ -0,0 +1,55 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+const env = 'FOO';
+
+if (!common.isWindows) {
+  // Verify that a faulty environment variable throws on bootstrapping.
+  // Therefore we do not need any special handling for the child process.
+  const child = cp.spawnSync(
+    process.execPath,
+    [`${__filename}`],
+    { env: { NODE_UNHANDLED_REJECTION: env } }
+  );
+
+  assert.strictEqual(child.stdout.toString(), '');
+  assert(child.stderr.includes(
+    `"${env}" for environment variable NODE_UNHANDLED_REJECTION`));
+}
+
+// Verify that a faulty environment variable throws on unhandled rejections.
+// TODO: This should throw immediately instead of detecting the faulty value
+// delayed.
+process.env.NODE_UNHANDLED_REJECTION = env;
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  common.expectsError({
+    type: TypeError,
+    code: 'ERR_INVALID_ENV_VALUE',
+    message: 'The value "FOO" for environment variable ' +
+             'NODE_UNHANDLED_REJECTION is invalid.'
+  })(err);
+  assert.strictEqual(origin, 'FROM_ERROR');
+}));
+
+process.on('unhandledRejection', common.mustCall(2));
+
+assert.strictEqual(process.env.NODE_UNHANDLED_REJECTION, env);
+setImmediate(() => {
+  assert.strictEqual(process.env.NODE_UNHANDLED_REJECTION, undefined);
+});
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('foo');
+
+// Should not do anything as the default is set to warning.
+global.gc();
+
+setTimeout(common.mustCall(), 5);
diff --git a/test/parallel/test-promise-unhandled-silent-no-hook.js b/test/parallel/test-promise-unhandled-silent-no-hook.js
new file mode 100644
index 00000000000000..de3bf67ce9ca9e
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-silent-no-hook.js
@@ -0,0 +1,24 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that ignoring unhandled rejection works fine and that no warning is
+// logged even though there is no unhandledRejection hook attached.
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('test');
+
+global.gc();
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+process.on('exit', assert.strictEqual.bind(null, 0));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promise-unhandled-silent.js b/test/parallel/test-promise-unhandled-silent.js
new file mode 100644
index 00000000000000..2448cff3c9de7b
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-silent.js
@@ -0,0 +1,25 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that ignoring unhandled rejection works fine and that no warning is
+// logged.
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+Promise.reject('test');
+
+global.gc();
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+
+process.on('unhandledRejection', common.mustCall(2));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promise-unhandled-warn-to-error.js b/test/parallel/test-promise-unhandled-warn-to-error.js
new file mode 100644
index 00000000000000..7113f84c76886f
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-warn-to-error.js
@@ -0,0 +1,28 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+
+process.env.NODE_UNHANDLED_REJECTION = 'SILENT';
+
+// Verify that setting the environment variable in a handler will this change
+// the behavior properly.
+
+Promise.reject('test');
+
+new Promise(() => {
+  throw new Error('One');
+});
+
+global.gc();
+
+process.on('unhandledRejection', () => {
+  process.env.NODE_UNHANDLED_REJECTION = 'ERROR';
+});
+process.on('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    message: 'One'
+  })(err);
+}));
+
+setTimeout(common.mustCall(), 2);
diff --git a/test/parallel/test-promises-unhandled-proxy-rejections.js b/test/parallel/test-promises-unhandled-proxy-rejections.js
index 83062e9520165b..912a777032e9e1 100644
--- a/test/parallel/test-promises-unhandled-proxy-rejections.js
+++ b/test/parallel/test-promises-unhandled-proxy-rejections.js
@@ -14,24 +14,26 @@ const expectedPromiseWarning = ['Unhandled promise rejection. ' +
   'block, or by rejecting a promise which was ' +
   'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
 
-function throwErr() {
-  throw new Error('Error from proxy');
+function throwErr(name) {
+  return function() {
+    throw new Error(`Error from ${name}`);
+  };
 }
 
 const thorny = new Proxy({}, {
-  getPrototypeOf: throwErr,
-  setPrototypeOf: throwErr,
-  isExtensible: throwErr,
-  preventExtensions: throwErr,
-  getOwnPropertyDescriptor: throwErr,
-  defineProperty: throwErr,
-  has: throwErr,
-  get: throwErr,
-  set: throwErr,
-  deleteProperty: throwErr,
-  ownKeys: throwErr,
-  apply: throwErr,
-  construct: throwErr
+  getPrototypeOf: throwErr('getPrototypeOf'),
+  setPrototypeOf: throwErr('setPrototypeOf'),
+  isExtensible: throwErr('isExtensible'),
+  preventExtensions: throwErr('preventExtensions'),
+  getOwnPropertyDescriptor: throwErr('getOwnPropertyDescriptor'),
+  defineProperty: throwErr('defineProperty'),
+  has: throwErr('has'),
+  get: throwErr('get'),
+  set: throwErr('set'),
+  deleteProperty: throwErr('deleteProperty'),
+  ownKeys: throwErr('ownKeys'),
+  apply: throwErr('apply'),
+  construct: throwErr('construct')
 });
 
 common.expectWarning({
diff --git a/test/parallel/test-timers-immediate-queue-throw.js b/test/parallel/test-timers-immediate-queue-throw.js
index 9929b27ab2fea3..c6e4859cf714b8 100644
--- a/test/parallel/test-timers-immediate-queue-throw.js
+++ b/test/parallel/test-timers-immediate-queue-throw.js
@@ -23,7 +23,10 @@ const errObj = {
   message: 'setImmediate Err'
 };
 
-process.once('uncaughtException', common.expectsError(errObj));
+process.once('uncaughtException', common.mustCall((err, errorOrigin) => {
+  assert.strictEqual(errorOrigin, 'FROM_ERROR');
+  common.expectsError(errObj)(err);
+}));
 process.once('uncaughtException', () => assert.strictEqual(stage, 0));
 
 const d1 = domain.create();
diff --git a/test/parallel/test-timers-unref-throw-then-ref.js b/test/parallel/test-timers-unref-throw-then-ref.js
index d3ae27e83551c7..1dd5fdd0ad2786 100644
--- a/test/parallel/test-timers-unref-throw-then-ref.js
+++ b/test/parallel/test-timers-unref-throw-then-ref.js
@@ -2,8 +2,10 @@
 const common = require('../common');
 const assert = require('assert');
 
-process.once('uncaughtException', common.expectsError({
-  message: 'Timeout Error'
+process.once('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    message: 'Timeout Error'
+  })(err);
 }));
 
 let called = false;
diff --git a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
index 36f73ea676e5a5..b4a9949af378a8 100644
--- a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
+++ b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
@@ -1,4 +1,3 @@
-// Flags: --abort-on-uncaught-exception
 'use strict';
 require('../common');
 const vm = require('vm');
@@ -7,8 +6,5 @@ const vm = require('vm');
 
 try {
   new vm.Script({ toString() { throw new Error('foo'); } }, {});
-} catch (err) {}
-
-try {
   new vm.Script('[', {});
 } catch (err) {}
diff --git a/test/pseudo-tty/test-tty-stdout-end.js b/test/pseudo-tty/test-tty-stdout-end.js
index 2ec7ca9114db6f..9e72a8118a6803 100644
--- a/test/pseudo-tty/test-tty-stdout-end.js
+++ b/test/pseudo-tty/test-tty-stdout-end.js
@@ -1,10 +1,12 @@
 'use strict';
 const common = require('../common');
 
-process.on('uncaughtException', common.expectsError({
-  code: 'ERR_STDOUT_CLOSE',
-  type: Error,
-  message: 'process.stdout cannot be closed'
+process.on('uncaughtException', common.mustCall((err) => {
+  common.expectsError({
+    code: 'ERR_STDOUT_CLOSE',
+    type: Error,
+    message: 'process.stdout cannot be closed'
+  })(err);
 }));
 
 process.stdout.end();