diff --git a/quic/core/congestion_control/bandwidth_sampler.h b/quic/core/congestion_control/bandwidth_sampler.h
index b3c0736..32b86af 100644
--- a/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quic/core/congestion_control/bandwidth_sampler.h
@@ -565,8 +565,7 @@
   MaxAckHeightTracker max_ack_height_tracker_;
   QuicByteCount total_bytes_acked_after_last_ack_event_;
 
-  // True if --quic_avoid_overestimate_bandwidth_with_aggregation=true and
-  // connection option 'BSAO' is set.
+  // True if connection option 'BSAO' is set.
   bool overestimate_avoidance_;
 };
 
diff --git a/quic/core/congestion_control/bandwidth_sampler_test.cc b/quic/core/congestion_control/bandwidth_sampler_test.cc
index 5dda998..f689553 100644
--- a/quic/core/congestion_control/bandwidth_sampler_test.cc
+++ b/quic/core/congestion_control/bandwidth_sampler_test.cc
@@ -34,8 +34,18 @@
 static_assert((kRegularPacketSize & 31) == 0,
               "kRegularPacketSize has to be five times divisible by 2");
 
+struct TestParameters {
+  bool overestimate_avoidance;
+};
+
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParameters& p) {
+  return p.overestimate_avoidance ? "enable_overestimate_avoidance"
+                                  : "no_enable_overestimate_avoidance";
+}
+
 // A test fixture with utility methods for BandwidthSampler tests.
-class BandwidthSamplerTest : public QuicTest {
+class BandwidthSamplerTest : public QuicTestWithParam<TestParameters> {
  protected:
   BandwidthSamplerTest()
       : sampler_(nullptr, /*max_height_tracker_window_length=*/0),
@@ -46,8 +56,7 @@
         round_trip_count_(0) {
     // Ensure that the clock does not start at zero.
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
-    if (GetQuicReloadableFlag(
-            quic_avoid_overestimate_bandwidth_with_aggregation)) {
+    if (GetParam().overestimate_avoidance) {
       sampler_.EnableOverestimateAvoidance();
     }
   }
@@ -170,8 +179,15 @@
   }
 };
 
+INSTANTIATE_TEST_SUITE_P(
+    BandwidthSamplerTests,
+    BandwidthSamplerTest,
+    testing::Values(TestParameters{/*overestimate_avoidance=*/false},
+                    TestParameters{/*overestimate_avoidance=*/true}),
+    testing::PrintToStringParamName());
+
 // Test the sampler in a simple stop-and-wait sender setting.
-TEST_F(BandwidthSamplerTest, SendAndWait) {
+TEST_P(BandwidthSamplerTest, SendAndWait) {
   QuicTime::Delta time_between_packets = QuicTime::Delta::FromMilliseconds(10);
   QuicBandwidth expected_bandwidth =
       QuicBandwidth::FromBytesPerSecond(kRegularPacketSize * 100);
@@ -200,7 +216,7 @@
   EXPECT_EQ(0u, bytes_in_flight_);
 }
 
-TEST_F(BandwidthSamplerTest, SendTimeState) {
+TEST_P(BandwidthSamplerTest, SendTimeState) {
   QuicTime::Delta time_between_packets = QuicTime::Delta::FromMilliseconds(10);
 
   // Send packets 1-5.
@@ -266,7 +282,7 @@
 
 // Test the sampler during regular windowed sender scenario with fixed
 // CWND of 20.
-TEST_F(BandwidthSamplerTest, SendPaced) {
+TEST_P(BandwidthSamplerTest, SendPaced) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -288,7 +304,7 @@
 }
 
 // Test the sampler in a scenario where 50% of packets is consistently lost.
-TEST_F(BandwidthSamplerTest, SendWithLosses) {
+TEST_P(BandwidthSamplerTest, SendWithLosses) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -333,7 +349,7 @@
 // congestion controlled (specifically, non-retransmittable data is not
 // congestion controlled).  Should be functionally consistent in behavior with
 // the SendWithLosses test.
-TEST_F(BandwidthSamplerTest, NotCongestionControlled) {
+TEST_P(BandwidthSamplerTest, NotCongestionControlled) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -382,7 +398,7 @@
 
 // Simulate a situation where ACKs arrive in burst and earlier than usual, thus
 // producing an ACK rate which is higher than the original send rate.
-TEST_F(BandwidthSamplerTest, CompressedAck) {
+TEST_P(BandwidthSamplerTest, CompressedAck) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -410,7 +426,7 @@
 }
 
 // Tests receiving ACK packets in the reverse order.
-TEST_F(BandwidthSamplerTest, ReorderedAck) {
+TEST_P(BandwidthSamplerTest, ReorderedAck) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -441,7 +457,7 @@
 }
 
 // Test the app-limited logic.
-TEST_F(BandwidthSamplerTest, AppLimited) {
+TEST_P(BandwidthSamplerTest, AppLimited) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   QuicBandwidth expected_bandwidth =
@@ -508,7 +524,7 @@
 }
 
 // Test the samples taken at the first flight of packets sent.
-TEST_F(BandwidthSamplerTest, FirstRoundTrip) {
+TEST_P(BandwidthSamplerTest, FirstRoundTrip) {
   const QuicTime::Delta time_between_packets =
       QuicTime::Delta::FromMilliseconds(1);
   const QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(800);
@@ -543,7 +559,7 @@
 }
 
 // Test sampler's ability to remove obsolete packets.
-TEST_F(BandwidthSamplerTest, RemoveObsoletePackets) {
+TEST_P(BandwidthSamplerTest, RemoveObsoletePackets) {
   SendPacket(1);
   SendPacket(2);
   SendPacket(3);
@@ -566,7 +582,7 @@
   EXPECT_EQ(0u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_));
 }
 
-TEST_F(BandwidthSamplerTest, NeuterPacket) {
+TEST_P(BandwidthSamplerTest, NeuterPacket) {
   SendPacket(1);
   EXPECT_EQ(0u, sampler_.total_bytes_neutered());
 
@@ -589,7 +605,7 @@
   EXPECT_EQ(0u, sample.extra_acked);
 }
 
-TEST_F(BandwidthSamplerTest, CongestionEventSampleDefaultValues) {
+TEST_P(BandwidthSamplerTest, CongestionEventSampleDefaultValues) {
   // Make sure a default constructed CongestionEventSample has the correct
   // initial values for BandwidthSampler::OnCongestionEvent() to work.
   BandwidthSampler::CongestionEventSample sample;
@@ -602,7 +618,7 @@
 }
 
 // 1) Send 2 packets, 2) Ack both in 1 event, 3) Repeat.
-TEST_F(BandwidthSamplerTest, TwoAckedPacketsPerEvent) {
+TEST_P(BandwidthSamplerTest, TwoAckedPacketsPerEvent) {
   QuicTime::Delta time_between_packets = QuicTime::Delta::FromMilliseconds(10);
   QuicBandwidth sending_rate = QuicBandwidth::FromBytesAndTimeDelta(
       kRegularPacketSize, time_between_packets);
@@ -631,7 +647,7 @@
   }
 }
 
-TEST_F(BandwidthSamplerTest, LoseEveryOtherPacket) {
+TEST_P(BandwidthSamplerTest, LoseEveryOtherPacket) {
   QuicTime::Delta time_between_packets = QuicTime::Delta::FromMilliseconds(10);
   QuicBandwidth sending_rate = QuicBandwidth::FromBytesAndTimeDelta(
       kRegularPacketSize, time_between_packets);
@@ -663,7 +679,7 @@
   }
 }
 
-TEST_F(BandwidthSamplerTest, AckHeightRespectBandwidthEstimateUpperBound) {
+TEST_P(BandwidthSamplerTest, AckHeightRespectBandwidthEstimateUpperBound) {
   QuicTime::Delta time_between_packets = QuicTime::Delta::FromMilliseconds(10);
   QuicBandwidth first_packet_sending_rate =
       QuicBandwidth::FromBytesAndTimeDelta(kRegularPacketSize,
@@ -693,10 +709,7 @@
 class MaxAckHeightTrackerTest : public QuicTest {
  protected:
   MaxAckHeightTrackerTest() : tracker_(/*initial_filter_window=*/10) {
-    if (GetQuicReloadableFlag(
-            quic_avoid_overestimate_bandwidth_with_aggregation)) {
-      tracker_.SetAckAggregationBandwidthThreshold(1.8);
-    }
+    tracker_.SetAckAggregationBandwidthThreshold(1.8);
   }
 
   // Run a full aggregation episode, which is one or more aggregated acks,
diff --git a/quic/core/congestion_control/bbr2_sender.cc b/quic/core/congestion_control/bbr2_sender.cc
index 7b891a6..d1b3159 100644
--- a/quic/core/congestion_control/bbr2_sender.cc
+++ b/quic/core/congestion_control/bbr2_sender.cc
@@ -95,11 +95,7 @@
   if (config.HasClientRequestedIndependentOption(kBBR9, perspective)) {
     params_.flexible_app_limited = true;
   }
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation) &&
-      config.HasClientRequestedIndependentOption(kBSAO, perspective)) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(
-        quic_avoid_overestimate_bandwidth_with_aggregation, 4, 4);
+  if (config.HasClientRequestedIndependentOption(kBSAO, perspective)) {
     model_.EnableOverestimateAvoidance();
   }
   if (config.HasClientRequestedIndependentOption(kB2NA, perspective)) {
diff --git a/quic/core/congestion_control/bbr2_simulator_test.cc b/quic/core/congestion_control/bbr2_simulator_test.cc
index f803ab6..205d356 100644
--- a/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -427,10 +427,7 @@
 }
 
 TEST_F(Bbr2DefaultTopologyTest, SimpleTransfer2RTTAggregationBytes) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   DefaultTopologyParams params;
   CreateNetwork(params);
   // 2 RTTs of aggregation, with a max of 10kb.
@@ -440,17 +437,9 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_TRUE(Bbr2ModeIsOneOf({Bbr2Mode::PROBE_BW, Bbr2Mode::PROBE_RTT}));
 
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
-                     sender_->ExportDebugState().bandwidth_hi, 0.01f);
-  } else {
-    EXPECT_LE(params.BottleneckBandwidth() * 0.99f,
-              sender_->ExportDebugState().bandwidth_hi);
-    // TODO(b/36022633): Bandwidth sampler overestimates with aggregation.
-    EXPECT_GE(params.BottleneckBandwidth() * 1.5f,
-              sender_->ExportDebugState().bandwidth_hi);
-  }
+  EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
+                   sender_->ExportDebugState().bandwidth_hi, 0.01f);
+
   EXPECT_LE(sender_loss_rate_in_packets(), 0.05);
   // The margin here is high, because the aggregation greatly increases
   // smoothed rtt.
@@ -459,10 +448,7 @@
 }
 
 TEST_F(Bbr2DefaultTopologyTest, SimpleTransferAckDecimation) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   // Enable Ack Decimation on the receiver.
   QuicConnectionPeer::SetAckMode(receiver_endpoint_.connection(),
                                  AckMode::ACK_DECIMATION);
@@ -473,17 +459,9 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_TRUE(Bbr2ModeIsOneOf({Bbr2Mode::PROBE_BW, Bbr2Mode::PROBE_RTT}));
 
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
-                     sender_->ExportDebugState().bandwidth_hi, 0.01f);
-  } else {
-    EXPECT_LE(params.BottleneckBandwidth() * 0.99f,
-              sender_->ExportDebugState().bandwidth_hi);
-    // TODO(b/36022633): Bandwidth sampler overestimates with aggregation.
-    EXPECT_GE(params.BottleneckBandwidth() * 1.1f,
-              sender_->ExportDebugState().bandwidth_hi);
-  }
+  EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
+                   sender_->ExportDebugState().bandwidth_hi, 0.01f);
+
   EXPECT_LE(sender_loss_rate_in_packets(), 0.001);
   EXPECT_FALSE(sender_->ExportDebugState().last_sample_is_app_limited);
   // The margin here is high, because the aggregation greatly increases
diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index e5751cf..9d1f3e1 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -313,11 +313,7 @@
     max_congestion_window_with_network_parameters_adjusted_ =
         100 * kDefaultTCPMSS;
   }
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation) &&
-      config.HasClientRequestedIndependentOption(kBSAO, perspective)) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(
-        quic_avoid_overestimate_bandwidth_with_aggregation, 3, 4);
+  if (config.HasClientRequestedIndependentOption(kBSAO, perspective)) {
     sampler_.EnableOverestimateAvoidance();
   }
 
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index e50a7c0..d1661de 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -389,10 +389,7 @@
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest, SimpleTransfer2RTTAggregationBytes) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   CreateDefaultSetup();
   // 2 RTTs of aggregation, with a max of 10kb.
   EnableAggregation(10 * 1024, 2 * kTestRtt);
@@ -401,20 +398,10 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_TRUE(sender_->ExportDebugState().mode == BbrSender::PROBE_BW ||
               sender_->ExportDebugState().mode == BbrSender::PROBE_RTT);
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(kTestLinkBandwidth,
-                     sender_->ExportDebugState().max_bandwidth, 0.01f);
-  } else {
-    // It's possible to read a bandwidth as much as 50% too high with
-    // aggregation.
-    EXPECT_LE(kTestLinkBandwidth * 0.93f,
-              sender_->ExportDebugState().max_bandwidth);
-    // TODO(ianswett): Tighten this bound once we understand why BBR is
-    // overestimating bandwidth with aggregation. b/36022633
-    EXPECT_GE(kTestLinkBandwidth * 1.5f,
-              sender_->ExportDebugState().max_bandwidth);
-  }
+
+  EXPECT_APPROX_EQ(kTestLinkBandwidth,
+                   sender_->ExportDebugState().max_bandwidth, 0.01f);
+
   // The margin here is high, because the aggregation greatly increases
   // smoothed rtt.
   EXPECT_GE(kTestRtt * 4, rtt_stats_->smoothed_rtt());
@@ -423,10 +410,7 @@
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest, SimpleTransferAckDecimation) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   // Decrease the CWND gain so extra CWND is required with stretch acks.
   SetQuicFlag(FLAGS_quic_bbr_cwnd_gain, 1.0);
   sender_ = new BbrSender(
@@ -446,20 +430,9 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_EQ(BbrSender::PROBE_BW, sender_->ExportDebugState().mode);
 
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(kTestLinkBandwidth,
-                     sender_->ExportDebugState().max_bandwidth, 0.01f);
-  } else {
-    // It's possible to read a bandwidth as much as 50% too high with
-    // aggregation.
-    EXPECT_LE(kTestLinkBandwidth * 0.93f,
-              sender_->ExportDebugState().max_bandwidth);
-    // TODO(ianswett): Tighten this bound once we understand why BBR is
-    // overestimating bandwidth with aggregation. b/36022633
-    EXPECT_GE(kTestLinkBandwidth * 1.5f,
-              sender_->ExportDebugState().max_bandwidth);
-  }
+  EXPECT_APPROX_EQ(kTestLinkBandwidth,
+                   sender_->ExportDebugState().max_bandwidth, 0.01f);
+
   // TODO(ianswett): Expect 0 packets are lost once BBR no longer measures
   // bandwidth higher than the link rate.
   EXPECT_FALSE(sender_->ExportDebugState().last_sample_is_app_limited);
@@ -471,10 +444,7 @@
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest, SimpleTransfer2RTTAggregationBytes20RTTWindow) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   // Disable Ack Decimation on the receiver, because it can increase srtt.
   QuicConnectionPeer::SetAckMode(receiver_.connection(), AckMode::TCP_ACKING);
   CreateDefaultSetup();
@@ -486,20 +456,10 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_TRUE(sender_->ExportDebugState().mode == BbrSender::PROBE_BW ||
               sender_->ExportDebugState().mode == BbrSender::PROBE_RTT);
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(kTestLinkBandwidth,
-                     sender_->ExportDebugState().max_bandwidth, 0.01f);
-  } else {
-    // It's possible to read a bandwidth as much as 50% too high with
-    // aggregation.
-    EXPECT_LE(kTestLinkBandwidth * 0.93f,
-              sender_->ExportDebugState().max_bandwidth);
-    // TODO(ianswett): Tighten this bound once we understand why BBR is
-    // overestimating bandwidth with aggregation. b/36022633
-    EXPECT_GE(kTestLinkBandwidth * 1.5f,
-              sender_->ExportDebugState().max_bandwidth);
-  }
+
+  EXPECT_APPROX_EQ(kTestLinkBandwidth,
+                   sender_->ExportDebugState().max_bandwidth, 0.01f);
+
   // TODO(ianswett): Expect 0 packets are lost once BBR no longer measures
   // bandwidth higher than the link rate.
   // The margin here is high, because the aggregation greatly increases
@@ -510,10 +470,7 @@
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest, SimpleTransfer2RTTAggregationBytes40RTTWindow) {
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    SetConnectionOption(kBSAO);
-  }
+  SetConnectionOption(kBSAO);
   // Disable Ack Decimation on the receiver, because it can increase srtt.
   QuicConnectionPeer::SetAckMode(receiver_.connection(), AckMode::TCP_ACKING);
   CreateDefaultSetup();
@@ -525,20 +482,10 @@
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_TRUE(sender_->ExportDebugState().mode == BbrSender::PROBE_BW ||
               sender_->ExportDebugState().mode == BbrSender::PROBE_RTT);
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_APPROX_EQ(kTestLinkBandwidth,
-                     sender_->ExportDebugState().max_bandwidth, 0.01f);
-  } else {
-    // It's possible to read a bandwidth as much as 50% too high with
-    // aggregation.
-    EXPECT_LE(kTestLinkBandwidth * 0.93f,
-              sender_->ExportDebugState().max_bandwidth);
-    // TODO(ianswett): Tighten this bound once we understand why BBR is
-    // overestimating bandwidth with aggregation. b/36022633
-    EXPECT_GE(kTestLinkBandwidth * 1.5f,
-              sender_->ExportDebugState().max_bandwidth);
-  }
+
+  EXPECT_APPROX_EQ(kTestLinkBandwidth,
+                   sender_->ExportDebugState().max_bandwidth, 0.01f);
+
   // TODO(ianswett): Expect 0 packets are lost once BBR no longer measures
   // bandwidth higher than the link rate.
   // The margin here is high, because the aggregation greatly increases
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 6b54afc..2c3ac9d 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -473,11 +473,7 @@
 void QuicSentPacketManager::NeuterUnencryptedPackets() {
   for (QuicPacketNumber packet_number :
        unacked_packets_.NeuterUnencryptedPackets()) {
-    if (avoid_overestimate_bandwidth_with_aggregation_) {
-      QUIC_RELOADABLE_FLAG_COUNT_N(
-          quic_avoid_overestimate_bandwidth_with_aggregation, 1, 4);
-      send_algorithm_->OnPacketNeutered(packet_number);
-    }
+    send_algorithm_->OnPacketNeutered(packet_number);
   }
   if (handshake_mode_disabled_) {
     consecutive_pto_count_ = 0;
@@ -488,11 +484,7 @@
 void QuicSentPacketManager::NeuterHandshakePackets() {
   for (QuicPacketNumber packet_number :
        unacked_packets_.NeuterHandshakePackets()) {
-    if (avoid_overestimate_bandwidth_with_aggregation_) {
-      QUIC_RELOADABLE_FLAG_COUNT_N(
-          quic_avoid_overestimate_bandwidth_with_aggregation, 2, 4);
-      send_algorithm_->OnPacketNeutered(packet_number);
-    }
+    send_algorithm_->OnPacketNeutered(packet_number);
   }
   if (handshake_mode_disabled_) {
     consecutive_pto_count_ = 0;
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index ac007fe..2513b82 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -652,9 +652,6 @@
   // If true, use standard deviation (instead of mean deviation) when
   // calculating PTO timeout.
   bool use_standard_deviation_for_pto_;
-
-  const bool avoid_overestimate_bandwidth_with_aggregation_ =
-      GetQuicReloadableFlag(quic_avoid_overestimate_bandwidth_with_aggregation);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index c0cbef9..8cfbafa 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -3758,11 +3758,7 @@
             return true;
           }));
 
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(2)))
-        .Times(1);
-  }
+  EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(2))).Times(1);
   manager_.SetHandshakeConfirmed();
 }
 
@@ -3776,11 +3772,8 @@
       .WillOnce(Return(false))
       .WillOnce(Return(true));
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
-  if (GetQuicReloadableFlag(
-          quic_avoid_overestimate_bandwidth_with_aggregation)) {
-    EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(1)))
-        .Times(1);
-  }
+
+  EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(1))).Times(1);
   manager_.NeuterUnencryptedPackets();
 }