diff --git a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
index 9c0d106..8dce6bd 100644
--- a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -672,11 +672,7 @@
   EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
                    sender_->ExportDebugState().bandwidth_hi, 0.01f);
 
-  if (GetQuicReloadableFlag(quic_fix_pacing_sender_bursts)) {
-    EXPECT_EQ(sender_loss_rate_in_packets(), 0);
-  } else {
-    EXPECT_LE(sender_loss_rate_in_packets(), 0.05);
-  }
+  EXPECT_EQ(sender_loss_rate_in_packets(), 0);
   // The margin here is high, because both link level aggregation and ack
   // decimation can greatly increase smoothed rtt.
   EXPECT_GE(params.RTT() * 5, rtt_stats()->smoothed_rtt());
@@ -698,11 +694,7 @@
   EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
                    sender_->ExportDebugState().bandwidth_hi, 0.5f);
 
-  if (GetQuicReloadableFlag(quic_fix_pacing_sender_bursts)) {
-    EXPECT_LE(sender_loss_rate_in_packets(), 0.01);
-  } else {
-    EXPECT_LE(sender_loss_rate_in_packets(), 0.05);
-  }
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.01);
   // The margin here is high, because both link level aggregation and ack
   // decimation can greatly increase smoothed rtt.
   EXPECT_GE(params.RTT() * 5, rtt_stats()->smoothed_rtt());
diff --git a/quiche/quic/core/congestion_control/pacing_sender.cc b/quiche/quic/core/congestion_control/pacing_sender.cc
index 1978158..46ba8a1 100644
--- a/quiche/quic/core/congestion_control/pacing_sender.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender.cc
@@ -94,9 +94,7 @@
       // is about 10ms of queueing.
       lumpy_tokens_ = 1u;
     }
-    if (GetQuicReloadableFlag(quic_fix_pacing_sender_bursts) &&
-        (bytes_in_flight + bytes) >= sender_->GetCongestionWindow()) {
-      QUIC_RELOADABLE_FLAG_COUNT(quic_fix_pacing_sender_bursts);
+    if ((bytes_in_flight + bytes) >= sender_->GetCongestionWindow()) {
       // Don't add lumpy_tokens if the congestion controller is CWND limited.
       lumpy_tokens_ = 1u;
     }
diff --git a/quiche/quic/core/congestion_control/pacing_sender_test.cc b/quiche/quic/core/congestion_control/pacing_sender_test.cc
index f53f445..7206b4c 100644
--- a/quiche/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender_test.cc
@@ -18,7 +18,6 @@
 
 using testing::_;
 using testing::AtMost;
-using testing::IsEmpty;
 using testing::Return;
 using testing::StrictMock;
 
@@ -340,8 +339,8 @@
   lost_packets.push_back(
       LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
   AckedPacketVector empty_acked;
-  EXPECT_CALL(*mock_sender_,
-              OnCongestionEvent(true, kMaxOutgoingPacketSize, _, IsEmpty(), _));
+  EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kMaxOutgoingPacketSize, _,
+                                               testing::IsEmpty(), _));
   pacing_sender_->OnCongestionEvent(true, kMaxOutgoingPacketSize, clock_.Now(),
                                     empty_acked, lost_packets);
   // One packet is sent immediately, because of 1ms pacing granularity.
@@ -501,23 +500,13 @@
   CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA,
                                10 * kMaxOutgoingPacketSize, false, 10);
 
-  if (GetQuicReloadableFlag(quic_fix_pacing_sender_bursts)) {
-    // The last sent packet made the connection CWND limited, so no lumpy tokens
-    // should be available.
-    EXPECT_EQ(0u, pacing_sender_->lumpy_tokens());
-    CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA,
-                                 10 * kMaxOutgoingPacketSize, false, 10);
-    EXPECT_EQ(0u, pacing_sender_->lumpy_tokens());
-    CheckPacketIsDelayed(2 * inter_packet_delay);
-  } else {
-    EXPECT_EQ(1u, pacing_sender_->lumpy_tokens());
-    // Repeatedly send single packets to make the sender CWND limited and
-    // observe that there's no pacing without the fix.
-    for (int i = 0; i < 10; ++i) {
-      CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA,
-                                   10 * kMaxOutgoingPacketSize, false, 10);
-    }
-  }
+  // The last sent packet made the connection CWND limited, so no lumpy tokens
+  // should be available.
+  EXPECT_EQ(0u, pacing_sender_->lumpy_tokens());
+  CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA,
+                               10 * kMaxOutgoingPacketSize, false, 10);
+  EXPECT_EQ(0u, pacing_sender_->lumpy_tokens());
+  CheckPacketIsDelayed(2 * inter_packet_delay);
 }
 
 TEST_F(PacingSenderTest, IdealNextPacketSendTimeWithLumpyPacing) {
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index a0424b8..908286b 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -89,8 +89,6 @@
 QUIC_FLAG(quic_restart_flag_quic_abstract_connection_id_generator, true)
 // When true, defaults to BBR congestion control instead of Cubic.
 QUIC_FLAG(quic_reloadable_flag_quic_default_to_bbr, false)
-// When true, prevents QUIC\'s PacingSender from generating bursts when the congestion controller is CWND limited and not pacing limited.
-QUIC_FLAG(quic_reloadable_flag_quic_fix_pacing_sender_bursts, true)
 // When true, set the initial congestion control window from connection options in QuicSentPacketManager rather than TcpCubicSenderBytes.
 QUIC_FLAG(quic_reloadable_flag_quic_unified_iw_options, true)
 // When true, support draft-ietf-quic-v2-01