diff --git a/doc/api/quic.md b/doc/api/quic.md
index 42a8b756909d1e..3667a05b394956 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -274,7 +274,7 @@ added: REPLACEME
   * `maxStatelessResetsPerHost` {number} The maximum number of stateless
     resets that the `QuicSocket` is permitted to send per remote host.
     Default: `10`.
-  * `qlog` {boolean} Whether to emit ['qlog'][] events for incoming sessions.
+  * `qlog` {boolean} Whether to enable ['qlog'][] for incoming sessions.
     (For outgoing client sessions, set `client.qlog`.) Default: `false`.
   * `retryTokenTimeout` {number} The maximum number of *seconds* for retry token
     validation. Default: `10` seconds.
@@ -633,20 +633,6 @@ The callback will be invoked with three arguments:
 
 The `'pathValidation'` event will be emitted multiple times.
 
-#### Event: `'qlog'`
-<!-- YAML
-added: REPLACEME
--->
-
-* `jsonChunk` {string} A JSON fragment.
-
-Emitted if the `qlog: true` option was passed to `quicsocket.connect()` or
-`net.createQuicSocket()` functions.
-
-The argument is a JSON fragment according to the [qlog standard][].
-
-The `'qlog'` event will be emitted multiple times.
-
 #### Event: `'secure'`
 <!-- YAML
 added: REPLACEME
@@ -1044,6 +1030,19 @@ added: REPLACEME
 A `BigInt` representing the total number of `QuicStreams` initiated by the
 connected peer.
 
+#### quicsession.qlog
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {stream.Readable}
+
+If `qlog` support is enabled for `QuicSession`, the `quicsession.qlog` property
+provides a [`stream.Readable`][] that may be used to access the `qlog` event
+data according to the [qlog standard][]. For client `QuicSessions`, the
+`quicsession.qlog` property will be `undefined` untilt the `'qlog'` event
+is emitted.
+
 #### quicsession.remoteAddress
 <!-- YAML
 added: REPLACEME
@@ -1183,6 +1182,17 @@ The `sessionTicket` and `remoteTransportParams` are useful when creating a new
 
 The `'sessionTicket'` event may be emitted multiple times.
 
+#### Event: `'qlog'`
+<!-- YAML
+added: REPLACEME
+-->
+
+The `'qlog'` event is emitted when the `QuicClientSession` is ready to begin
+providing `qlog` event data. The callback is invoked with a single argument:
+
+* `qlog` {stream.Readable} A [`stream.Readable`][] that is also available using
+  the `quicsession.qlog` property.
+
 #### Event: `'usePreferredAddress'`
 <!-- YAML
 added: REPLACEME
@@ -1573,7 +1583,7 @@ added: REPLACEME
     transport parameters from a previously established session. These would
     have been provided as part of the `'sessionTicket'` event on a previous
     `QuicClientSession` object.
-  * `qlog` {boolean} Whether to emit ['qlog'][] events for this session.
+  * `qlog` {boolean} Whether to enable ['qlog'][] for this session.
     Default: `false`.
   * `requestOCSP` {boolean} If `true`, specifies that the OCSP status request
     extension will be added to the client hello and an `'OCSPResponse'` event
@@ -2278,6 +2288,7 @@ added: REPLACEME
 Set to `true` if the `QuicStream` is unidirectional.
 
 [`crypto.getCurves()`]: crypto.html#crypto_crypto_getcurves
+[`stream.Readable`]: #stream_class_stream_readable
 [`tls.DEFAULT_ECDH_CURVE`]: #tls_tls_default_ecdh_curve
 [`tls.getCiphers()`]: tls.html#tls_tls_getciphers
 [ALPN]: https://tools.ietf.org/html/rfc7301
@@ -2286,5 +2297,5 @@ Set to `true` if the `QuicStream` is unidirectional.
 [modifying the default cipher suite]: tls.html#tls_modifying_the_default_tls_cipher_suite
 [OpenSSL Options]: crypto.html#crypto_openssl_options
 [Perfect Forward Secrecy]: #tls_perfect_forward_secrecy
-['qlog']: #quic_event_qlog
+['qlog']: #quic_quicsession_qlog
 [qlog standard]: https://tools.ietf.org/id/draft-marx-qlog-event-definitions-quic-h3-00.html
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index babbdb39bcf6d9..257ffb2b2b02d4 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -40,6 +40,7 @@ const {
   validateCreateSecureContextOptions,
   validateQuicSocketConnectOptions,
   QuicSessionSharedState,
+  QLogStream,
 } = require('internal/quic/util');
 const util = require('util');
 const assert = require('internal/assert');
@@ -236,6 +237,7 @@ const kRemoveSession = Symbol('kRemove');
 const kRemoveStream = Symbol('kRemoveStream');
 const kServerBusy = Symbol('kServerBusy');
 const kSetHandle = Symbol('kSetHandle');
+const kSetQLogStream = Symbol('kSetQLogStream');
 const kSetSocket = Symbol('kSetSocket');
 const kSetSocketAfterBind = Symbol('kSetSocketAfterBind');
 const kStartFilePipe = Symbol('kStartFilePipe');
@@ -423,37 +425,17 @@ function onSessionUsePreferredAddress(address, port, family) {
   });
 }
 
-// Called by the C++ internals to emit a QLog record.
-function onSessionQlog(str) {
-  if (this.qlogBuffer === undefined) this.qlogBuffer = '';
-
+// Called by the C++ internals to emit a QLog record. This can
+// be called before the QuicSession has been fully initialized,
+// in which case we store a reference and defer emitting the
+// qlog event until after we're initialized.
+function onSessionQlog(handle) {
   const session = this[owner_symbol];
-
-  if (session && session.listenerCount('qlog') > 0) {
-    // Emit this chunk along with any previously buffered data.
-    str = this.qlogBuffer + str;
-    this.qlogBuffer = '';
-    if (str === '') return;
-    session.emit('qlog', str);
-  } else {
-    // Buffer the data until both the JS session object and a listener
-    // become available.
-    this.qlogBuffer += str;
-
-    if (!session || this.waitingForQlogListener) return;
-    this.waitingForQlogListener = true;
-
-    function onNewListener(ev) {
-      if (ev === 'qlog') {
-        session.removeListener('newListener', onNewListener);
-        process.nextTick(() => {
-          onSessionQlog.call(this, '');
-        });
-      }
-    }
-
-    session.on('newListener', onNewListener);
-  }
+  const stream = new QLogStream(handle);
+  if (session)
+    session[kSetQLogStream](stream);
+  else
+    this.qlogStream = stream;
 }
 
 // Called by the C++ internals when a client QuicSession receives
@@ -1631,6 +1613,7 @@ class QuicSession extends EventEmitter {
     highWaterMark: undefined,
     defaultEncoding: undefined,
     state: undefined,
+    qlogStream: undefined,
   };
 
   constructor(socket, options) {
@@ -1662,6 +1645,14 @@ class QuicSession extends EventEmitter {
     };
   }
 
+  [kSetQLogStream](stream) {
+    const state = this[kInternalState];
+    state.qlogStream = stream;
+    process.nextTick(() => {
+      this.emit('qlog', state.qlogStream);
+    });
+  }
+
   // Sets the internal handle for the QuicSession instance. For
   // server QuicSessions, this is called immediately as the
   // handle is created before the QuicServerSession JS object.
@@ -1676,6 +1667,10 @@ class QuicSession extends EventEmitter {
       state.state = new QuicSessionSharedState(handle.state);
       state.handshakeAckHistogram = new Histogram(handle.ack);
       state.handshakeContinuationHistogram = new Histogram(handle.rate);
+      if (handle.qlogStream !== undefined) {
+        this[kSetQLogStream](handle.qlogStream);
+        handle.qlogStream = undefined;
+      }
     } else {
       if (state.handshakeAckHistogram)
         state.handshakeAckHistogram[kDestroyHistogram]();
@@ -1934,6 +1929,10 @@ class QuicSession extends EventEmitter {
     return { bidi, uni };
   }
 
+  get qlog() {
+    return this[kInternalState].qlogStream;
+  }
+
   get address() {
     return this[kInternalState].socket?.address || {};
   }
diff --git a/lib/internal/quic/util.js b/lib/internal/quic/util.js
index 6bbe10959723a9..b5a6e8ed690718 100644
--- a/lib/internal/quic/util.js
+++ b/lib/internal/quic/util.js
@@ -15,12 +15,24 @@ const {
   },
 } = require('internal/errors');
 
+const {
+  symbols: {
+    owner_symbol,
+  },
+} = require('internal/async_hooks');
+
 const {
   kHandle,
 } = require('internal/stream_base_commons');
 
 const endianness = require('os').endianness();
 
+const { Readable } = require('stream');
+const {
+  kUpdateTimer,
+  onStreamRead,
+} = require('internal/stream_base_commons');
+
 const assert = require('internal/assert');
 assert(process.versions.ngtcp2 !== undefined);
 
@@ -885,6 +897,31 @@ class QuicSessionSharedState {
   }
 }
 
+class QLogStream extends Readable {
+  constructor(handle) {
+    super({ autoDestroy: true });
+    this[kHandle] = handle;
+    handle[owner_symbol] = this;
+    handle.onread = onStreamRead;
+  }
+
+  _read() {
+    if (this[kHandle])
+      this[kHandle].readStart();
+  }
+
+  _destroy() {
+    // Release the references on the handle so that
+    // it can be garbage collected.
+    this[kHandle][owner_symbol] = undefined;
+    this[kHandle] = undefined;
+  }
+
+  [kUpdateTimer]() {
+    // Does nothing
+  }
+}
+
 module.exports = {
   getAllowUnauthorized,
   getSocketType,
@@ -903,4 +940,5 @@ module.exports = {
   validateCreateSecureContextOptions,
   validateQuicSocketConnectOptions,
   QuicSessionSharedState,
+  QLogStream,
 };
diff --git a/src/async_wrap.h b/src/async_wrap.h
index 2a8c80c2f0028a..dfaad1de79888f 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -59,6 +59,7 @@ namespace node {
   V(PROCESSWRAP)                                                              \
   V(PROMISE)                                                                  \
   V(QUERYWRAP)                                                                \
+  V(QLOGSTREAM)                                                               \
   V(QUICCLIENTSESSION)                                                        \
   V(QUICSERVERSESSION)                                                        \
   V(QUICSENDWRAP)                                                             \
diff --git a/src/env.h b/src/env.h
index 07e8307f056640..0c1d785cc2743c 100644
--- a/src/env.h
+++ b/src/env.h
@@ -441,6 +441,7 @@ constexpr size_t kFsStatsBufferLength =
   V(secure_context_constructor_template, v8::FunctionTemplate)                 \
   V(shutdown_wrap_template, v8::ObjectTemplate)                                \
   V(streambaseoutputstream_constructor_template, v8::ObjectTemplate)           \
+  V(qlogoutputstream_constructor_template, v8::ObjectTemplate)                 \
   V(tcp_constructor_template, v8::FunctionTemplate)                            \
   V(tty_constructor_template, v8::FunctionTemplate)                            \
   V(write_wrap_template, v8::ObjectTemplate)                                   \
diff --git a/src/quic/node_quic_session.cc b/src/quic/node_quic_session.cc
index 0ac7d2ec6fa2a2..92657f48b2a3c0 100644
--- a/src/quic/node_quic_session.cc
+++ b/src/quic/node_quic_session.cc
@@ -2,6 +2,7 @@
 #include "aliased_buffer.h"
 #include "aliased_struct-inl.h"
 #include "allocated_buffer-inl.h"
+#include "async_wrap-inl.h"
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "node_crypto_common.h"
@@ -25,9 +26,11 @@
 #include "node_quic_default_application.h"
 #include "node_quic_http3_application.h"
 #include "node_sockaddr-inl.h"
+#include "stream_base-inl.h"
 #include "v8.h"
 #include "uv.h"
 
+#include <algorithm>
 #include <vector>
 #include <string>
 #include <utility>
@@ -339,9 +342,9 @@ void QuicSessionListener::OnVersionNegotiation(
     previous_listener_->OnVersionNegotiation(supported_version, versions, vcnt);
 }
 
-void QuicSessionListener::OnQLog(const uint8_t* data, size_t len) {
+void QuicSessionListener::OnQLog(QLogStream* qlog_stream) {
   if (previous_listener_ != nullptr)
-    previous_listener_->OnQLog(data, len);
+    previous_listener_->OnQLog(qlog_stream);
 }
 
 void JSQuicSessionListener::OnKeylog(const char* line, size_t len) {
@@ -709,13 +712,13 @@ void JSQuicSessionListener::OnVersionNegotiation(
       arraysize(argv), argv);
 }
 
-void JSQuicSessionListener::OnQLog(const uint8_t* data, size_t len) {
+void JSQuicSessionListener::OnQLog(QLogStream* qlog_stream) {
+  CHECK_NOT_NULL(qlog_stream);
   Environment* env = session()->env();
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
-
-  Local<Value> str = OneByteString(env->isolate(), data, len);
-  session()->MakeCallback(env->quic_on_session_qlog_function(), 1, &str);
+  Local<Value> obj = qlog_stream->object();
+  session()->MakeCallback(env->quic_on_session_qlog_function(), 1, &obj);
 }
 
 // Generates a new random connection ID.
@@ -1457,6 +1460,10 @@ QuicSession::QuicSession(
 QuicSession::~QuicSession() {
   CHECK(!Ngtcp2CallbackScope::InNgtcp2CallbackScope(this));
 
+  // The next write should be the final one
+  if (qlog_stream_)
+    qlog_stream_->End();
+
   QuicSessionListener* listener_ = listener();
   if (listener_ == listener())
     RemoveListener(listener_);
@@ -1681,6 +1688,8 @@ void QuicSession::Destroy() {
   if (is_destroyed())
     return;
 
+  Debug(this, "Destroying the QuicSession");
+
   // Mark the session destroyed.
   set_destroyed();
   set_closing(false);
@@ -3222,9 +3231,31 @@ int QuicSession::OnStatelessReset(
   return 0;
 }
 
+BaseObjectPtr<QLogStream> QuicSession::qlog_stream() {
+  if (!qlog_stream_) {
+    CHECK(qlog_stream_ = QLogStream::Create(env()));
+    listener_->OnQLog(qlog_stream_.get());
+  }
+  return qlog_stream_;
+}
+
 void QuicSession::OnQlogWrite(void* user_data, const void* data, size_t len) {
   QuicSession* session = static_cast<QuicSession*>(user_data);
-  session->listener()->OnQLog(reinterpret_cast<const uint8_t*>(data), len);
+  Environment* env = session->env();
+
+  // Fun fact... ngtcp2 does not emit the final qlog statement until the
+  // ngtcp2_conn object is destroyed. Ideally, destroying is explicit,
+  // but sometimes the QuicSession object can be garbage collected without
+  // being explicitly destroyed. During those times, we cannot call out
+  // to JavaScript. Because we don't know for sure if we're in in a GC
+  // when this is called, it is safer to just defer writes to immediate.
+  BaseObjectPtr<QLogStream> ptr = session->qlog_stream();
+  std::vector<uint8_t> buffer(len);
+  memcpy(buffer.data(), data, len);
+  env->SetImmediate([ptr = std::move(ptr),
+                     buffer = std::move(buffer)](Environment*) {
+    ptr->Emit(buffer.data(), buffer.size());
+  });
 }
 
 const ngtcp2_conn_callbacks QuicSession::callbacks[2] = {
@@ -3296,6 +3327,73 @@ const ngtcp2_conn_callbacks QuicSession::callbacks[2] = {
   }
 };
 
+BaseObjectPtr<QLogStream> QLogStream::Create(Environment* env) {
+  HandleScope scope(env->isolate());
+
+  // TODO(@jasnell): There is identical code in heap_utils for the
+  // HeapSnapshotStream. We can consolidate the two.
+  if (env->qlogoutputstream_constructor_template().IsEmpty()) {
+    // Create FunctionTemplate for QLogStream
+    Local<FunctionTemplate> os = FunctionTemplate::New(env->isolate());
+    os->Inherit(AsyncWrap::GetConstructorTemplate(env));
+    Local<ObjectTemplate> ost = os->InstanceTemplate();
+    ost->SetInternalFieldCount(StreamBase::kInternalFieldCount);
+    os->SetClassName(
+        FIXED_ONE_BYTE_STRING(env->isolate(), "QLogStream"));
+    StreamBase::AddMethods(env, os);
+    env->set_qlogoutputstream_constructor_template(ost);
+  }
+
+  Local<Object> obj;
+  if (!env->qlogoutputstream_constructor_template()
+          ->NewInstance(env->context())
+              .ToLocal(&obj)) {
+    return {};
+  }
+
+  return MakeBaseObject<QLogStream>(env, obj);
+}
+
+QLogStream::QLogStream(Environment* env, v8::Local<Object> obj)
+    : AsyncWrap(env, obj, AsyncWrap::PROVIDER_QLOGSTREAM),
+      StreamBase(env) {
+  MakeWeak();
+  StreamBase::AttachToObject(GetObject());
+}
+
+void QLogStream::Emit(const uint8_t* data, size_t len) {
+  size_t remaining = len;
+  while (remaining != 0) {
+    uv_buf_t buf = EmitAlloc(len);
+    ssize_t avail = std::min<size_t>(remaining, buf.len);
+    memcpy(buf.base, data, avail);
+    remaining -= avail;
+    data += avail;
+    EmitRead(avail, buf);
+  }
+
+  // The last chunk that ngtcp2 writes is 6 bytes. Unfortunately,
+  // this is the only way for us to know that ngtcp2 is definitely
+  // done sending qlog events.
+  if (ended_ && len == 6)
+    EmitRead(UV_EOF);
+}
+
+int QLogStream::DoShutdown(ShutdownWrap* req_wrap) {
+  UNREACHABLE();
+}
+
+int QLogStream::DoWrite(
+    WriteWrap* w,
+    uv_buf_t* bufs,
+    size_t count,
+    uv_stream_t* send_handle) {
+  UNREACHABLE();
+}
+
+bool QLogStream::IsAlive() { return true; }
+bool QLogStream::IsClosing() { return false; }
+
 // JavaScript API
 
 namespace {
diff --git a/src/quic/node_quic_session.h b/src/quic/node_quic_session.h
index 7556e2fc5878a3..ef9948f235823b 100644
--- a/src/quic/node_quic_session.h
+++ b/src/quic/node_quic_session.h
@@ -17,6 +17,7 @@
 #include "node_quic_crypto.h"
 #include "node_quic_util.h"
 #include "node_sockaddr.h"
+#include "stream_base.h"
 #include "v8.h"
 #include "uv.h"
 
@@ -224,6 +225,36 @@ struct QuicSessionStatsTraits {
   static void ToString(const Base& ptr, Fn&& add_field);
 };
 
+class QLogStream : public AsyncWrap,
+                   public StreamBase {
+ public:
+  static BaseObjectPtr<QLogStream> Create(Environment* env);
+
+  QLogStream(Environment* env, v8::Local<v8::Object> obj);
+
+  void Emit(const uint8_t* data, size_t len);
+
+  void End() { ended_ = true; }
+
+  int ReadStart() override { return 0; }
+  int ReadStop() override { return 0; }
+  int DoShutdown(ShutdownWrap* req_wrap) override;
+  int DoWrite(WriteWrap* w,
+              uv_buf_t* bufs,
+              size_t count,
+              uv_stream_t* send_handle) override;
+  bool IsAlive() override;
+  bool IsClosing() override;
+  AsyncWrap* GetAsyncWrap() override { return this; }
+
+  SET_NO_MEMORY_INFO();
+  SET_MEMORY_INFO_NAME(QLogStream);
+  SET_SELF_SIZE(QLogStream);
+
+ private:
+  bool ended_ = false;
+};
+
 class QuicSessionListener {
  public:
   enum SessionCloseFlags {
@@ -269,7 +300,7 @@ class QuicSessionListener {
       uint32_t supported_version,
       const uint32_t* versions,
       size_t vcnt);
-  virtual void OnQLog(const uint8_t* data, size_t len);
+  virtual void OnQLog(QLogStream* qlog_stream);
 
   QuicSession* session() const { return session_.get(); }
 
@@ -316,7 +347,7 @@ class JSQuicSessionListener : public QuicSessionListener {
       uint32_t supported_version,
       const uint32_t* versions,
       size_t vcnt) override;
-  void OnQLog(const uint8_t* data, size_t len) override;
+  void OnQLog(QLogStream* qlog_stream) override;
 
  private:
   friend class QuicSession;
@@ -844,6 +875,8 @@ class QuicSession : public AsyncWrap,
 
   size_t max_packet_length() const { return max_pktlen_; }
 
+  BaseObjectPtr<QLogStream> qlog_stream();
+
   // Get the ALPN protocol identifier configured for this QuicSession.
   // For server sessions, this will be compared against the client requested
   // ALPN identifier to determine if there is a protocol match.
@@ -1014,7 +1047,7 @@ class QuicSession : public AsyncWrap,
   // to the peer. If Close is called while within the ngtcp2
   // callback scope, sending the CONNECTION_CLOSE will be
   // deferred until the ngtcp2 callback scope exits.
-  inline void Close(
+  void Close(
       int close_flags = QuicSessionListener::SESSION_CLOSE_FLAG_NONE);
 
   void PushListener(QuicSessionListener* listener);
@@ -1088,7 +1121,7 @@ class QuicSession : public AsyncWrap,
         return;
       }
       session_->set_in_connection_close_scope(false);
-      bool ret = session_->SendConnectionClose();
+      session_->SendConnectionClose();
     }
 
    private:
@@ -1460,6 +1493,7 @@ class QuicSession : public AsyncWrap,
   static const ngtcp2_conn_callbacks callbacks[2];
 
   BaseObjectPtr<QuicState> quic_state_;
+  BaseObjectWeakPtr<QLogStream> qlog_stream_;
 
   friend class QuicCryptoContext;
   friend class QuicSessionListener;
diff --git a/test/parallel/test-quic-qlog.js b/test/parallel/test-quic-qlog.js
index 3306a539379e8f..692b90436fe84a 100644
--- a/test/parallel/test-quic-qlog.js
+++ b/test/parallel/test-quic-qlog.js
@@ -55,12 +55,22 @@ server.on('ready', common.mustCall(() => {
   }));
 }));
 
-function gatherQlog(session, id) {
-  let log = '';
-  session.on('qlog', (chunk) => log += chunk);
-  session.on('close', common.mustCall(() => {
-    const { qlog_version, traces } = JSON.parse(log);
+function setupQlog(qlog) {
+  let data = '';
+  qlog.setEncoding('utf8');
+  qlog.on('data', (chunk) => data += chunk);
+  qlog.once('end', common.mustCall(() => {
+    const { qlog_version, traces } = JSON.parse(data);
     assert.strictEqual(typeof qlog_version, 'string');
-    assert.strictEqual(typeof traces[0].events, 'object');
+    assert.strictEqual(typeof traces, 'object');
   }));
 }
+
+function gatherQlog(session, id) {
+  switch (id) {
+    case 'server':
+      setupQlog(session.qlog);
+    case 'client':
+      session.on('qlog', setupQlog);
+  }
+}
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 17eb781e5d4b97..50a097febb8053 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -51,6 +51,7 @@ const { getSystemErrorName } = require('util');
     delete providers.QUICSENDWRAP;
     delete providers.QUICSOCKET;
     delete providers.QUICSTREAM;
+    delete providers.QLOGSTREAM;
     delete providers.JSUDPWRAP;
     if (!common.isMainThread)
       delete providers.INSPECTORJSBINDING;