diff --git a/quic/core/batch_writer/quic_batch_writer_base.cc b/quic/core/batch_writer/quic_batch_writer_base.cc
index 46e230c..51b6188 100644
--- a/quic/core/batch_writer/quic_batch_writer_base.cc
+++ b/quic/core/batch_writer/quic_batch_writer_base.cc
@@ -66,9 +66,9 @@
     ReleaseTime result{actual_release_time,
                        QuicTime::Delta::FromMicroseconds(offset_ns / 1000)};
 
-    QUIC_DLOG(INFO) << "ideal_release_time:" << ideal_release_time
-                    << ", actual_release_time:" << actual_release_time
-                    << ", offset:" << result.release_time_offset;
+    QUIC_DVLOG(1) << "ideal_release_time:" << ideal_release_time
+                  << ", actual_release_time:" << actual_release_time
+                  << ", offset:" << result.release_time_offset;
     return result;
   }
 
diff --git a/quic/core/batch_writer/quic_gso_batch_writer.cc b/quic/core/batch_writer/quic_gso_batch_writer.cc
index 56c0e10..fd023ae 100644
--- a/quic/core/batch_writer/quic_gso_batch_writer.cc
+++ b/quic/core/batch_writer/quic_gso_batch_writer.cc
@@ -66,18 +66,23 @@
   // [2] It won't cause this batch to exceed kMaxGsoPacketSize.
   // [3] Already buffered writes all have the same length.
   // [4] Length of already buffered writes must >= length of the new write.
-  // [5] The new packet has the same release time as buffered writes.
+  // [5] The new packet can be released without delay, or it has the same
+  //     release time as buffered writes.
   const BufferedWrite& first = buffered_writes().front();
   const BufferedWrite& last = buffered_writes().back();
+  // Whether this packet can be sent without delay, regardless of release time.
+  const bool can_burst = !SupportsReleaseTime() || !options ||
+                         options->release_time_delay.IsZero() ||
+                         options->allow_burst;
   size_t max_segments = MaxSegments(first.buf_len);
   bool can_batch =
-      buffered_writes().size() < max_segments &&                       // [0]
-      last.self_address == self_address &&                             // [1]
-      last.peer_address == peer_address &&                             // [1]
-      batch_buffer().SizeInUse() + buf_len <= kMaxGsoPacketSize &&     // [2]
-      first.buf_len == last.buf_len &&                                 // [3]
-      first.buf_len >= buf_len &&                                      // [4]
-      (!SupportsReleaseTime() || first.release_time == release_time);  // [5]
+      buffered_writes().size() < max_segments &&                    // [0]
+      last.self_address == self_address &&                          // [1]
+      last.peer_address == peer_address &&                          // [1]
+      batch_buffer().SizeInUse() + buf_len <= kMaxGsoPacketSize &&  // [2]
+      first.buf_len == last.buf_len &&                              // [3]
+      first.buf_len >= buf_len &&                                   // [4]
+      (can_burst || first.release_time == release_time);            // [5]
 
   // A flush is required if any of the following is true:
   // [a] The new write can't be batched.
diff --git a/quic/core/batch_writer/quic_gso_batch_writer_test.cc b/quic/core/batch_writer/quic_gso_batch_writer_test.cc
index 158783d..d202c67 100644
--- a/quic/core/batch_writer/quic_gso_batch_writer_test.cc
+++ b/quic/core/batch_writer/quic_gso_batch_writer_test.cc
@@ -249,25 +249,27 @@
     for (size_t j = 0; j < test_data_table.size(); ++j) {
       const BatchCriteriaTestData& test_data = test_data_table[j];
       SCOPED_TRACE(testing::Message() << "i=" << i << ", j=" << j);
+      TestPerPacketOptions options;
+      options.release_time_delay = QuicTime::Delta::FromMicroseconds(
+          test_data.buffered_write.release_time);
       TestQuicGsoBatchWriter::CanBatchResult result = writer->CanBatch(
           test_data.buffered_write.buffer, test_data.buffered_write.buf_len,
           test_data.buffered_write.self_address,
-          test_data.buffered_write.peer_address,
-          /*options=*/nullptr, test_data.buffered_write.release_time);
+          test_data.buffered_write.peer_address, &options,
+          test_data.buffered_write.release_time);
 
       ASSERT_EQ(test_data.can_batch, result.can_batch);
       ASSERT_EQ(test_data.must_flush, result.must_flush);
 
       if (result.can_batch) {
-        ASSERT_TRUE(
-            writer->batch_buffer()
-                .PushBufferedWrite(test_data.buffered_write.buffer,
-                                   test_data.buffered_write.buf_len,
-                                   test_data.buffered_write.self_address,
-                                   test_data.buffered_write.peer_address,
-                                   /*options=*/nullptr,
-                                   test_data.buffered_write.release_time)
-                .succeeded);
+        ASSERT_TRUE(writer->batch_buffer()
+                        .PushBufferedWrite(
+                            test_data.buffered_write.buffer,
+                            test_data.buffered_write.buf_len,
+                            test_data.buffered_write.self_address,
+                            test_data.buffered_write.peer_address, &options,
+                            test_data.buffered_write.release_time)
+                        .succeeded);
       }
     }
   }
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 8c395a5..a979139 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2737,8 +2737,6 @@
   if (result.status == WRITE_STATUS_OK) {
     // packet_send_time is the ideal send time, if allow_burst is true, writer
     // may have sent it earlier than that.
-    DCHECK((per_packet_options_ && per_packet_options_->allow_burst) ||
-           result.send_time_offset.IsZero());
     packet_send_time = packet_send_time + result.send_time_offset;
   }