diff --git a/quic/core/congestion_control/bbr2_misc.cc b/quic/core/congestion_control/bbr2_misc.cc
index 0be3253..eb29983 100644
--- a/quic/core/congestion_control/bbr2_misc.cc
+++ b/quic/core/congestion_control/bbr2_misc.cc
@@ -168,6 +168,7 @@
     inflight_latest_ = sample.sample_max_inflight;
   }
 
+  // Adapt lower bounds(bandwidth_lo and inflight_lo).
   AdaptLowerBounds(*congestion_event);
 
   if (!congestion_event->end_of_round_trip) {
@@ -185,6 +186,63 @@
 
 void Bbr2NetworkModel::AdaptLowerBounds(
     const Bbr2CongestionEvent& congestion_event) {
+  if (Params().bw_lo_mode_ != Bbr2Params::DEFAULT) {
+    DCHECK(Params().bw_startup);
+    if (congestion_event.bytes_lost == 0) {
+      return;
+    }
+    // Ignore losses from packets sent when probing for more bandwidth in
+    // STARTUP or PROBE_UP when they're lost in DRAIN or PROBE_DOWN.
+    if (pacing_gain_ < 1) {
+      return;
+    }
+    // Decrease bandwidth_lo whenever there is loss.
+    // Set bandwidth_lo_ if it is not yet set.
+    if (bandwidth_lo_.IsInfinite()) {
+      bandwidth_lo_ = MaxBandwidth();
+    }
+    switch (Params().bw_lo_mode_) {
+      case Bbr2Params::MIN_RTT_REDUCTION:
+        bandwidth_lo_ =
+            bandwidth_lo_ - QuicBandwidth::FromBytesAndTimeDelta(
+                                congestion_event.bytes_lost, MinRtt());
+        break;
+      case Bbr2Params::INFLIGHT_REDUCTION: {
+        // Use a max of BDP and inflight to avoid starving app-limited flows.
+        const QuicByteCount effective_inflight =
+            std::max(BDP(), congestion_event.prior_bytes_in_flight);
+        // This could use bytes_lost_in_round if the bandwidth_lo_ was saved
+        // when entering 'recovery', but this BBRv2 implementation doesn't have
+        // recovery defined.
+        bandwidth_lo_ = bandwidth_lo_ *
+                        ((effective_inflight - congestion_event.bytes_lost) /
+                         static_cast<double>(effective_inflight));
+        break;
+      }
+      case Bbr2Params::CWND_REDUCTION:
+        bandwidth_lo_ =
+            bandwidth_lo_ *
+            ((congestion_event.prior_cwnd - congestion_event.bytes_lost) /
+             static_cast<double>(congestion_event.prior_cwnd));
+        break;
+      case Bbr2Params::DEFAULT:
+        QUIC_BUG << "Unreachable case DEFAULT.";
+    }
+    if (pacing_gain_ > Params().startup_full_bw_threshold) {
+      // In STARTUP, pacing_gain_ is applied to bandwidth_lo_, so this backs
+      // that multiplication out to allow the pacing rate to decrease,
+      // but not below bandwidth_latest_ * startup_full_bw_threshold.
+      bandwidth_lo_ =
+          std::max(bandwidth_lo_,
+                   bandwidth_latest_ *
+                       (Params().startup_full_bw_threshold / pacing_gain_));
+    } else {
+      // Ensure bandwidth_lo isn't lower than bandwidth_latest_.
+      bandwidth_lo_ = std::max(bandwidth_lo_, bandwidth_latest_);
+    }
+    // This early return ignores inflight_lo as well.
+    return;
+  }
   if (!congestion_event.end_of_round_trip ||
       congestion_event.is_probing_for_bandwidth) {
     return;
diff --git a/quic/core/congestion_control/bbr2_misc.h b/quic/core/congestion_control/bbr2_misc.h
index c26d2f9..f02e22d 100644
--- a/quic/core/congestion_control/bbr2_misc.h
+++ b/quic/core/congestion_control/bbr2_misc.h
@@ -195,6 +195,23 @@
 
   // Can be disabled by connection option 'B2RC'.
   bool enable_reno_coexistence = true;
+
+  // For experimentation to improve fast convergence upon loss.
+  enum QuicBandwidthLoMode : uint8_t {
+    DEFAULT = 0,
+    MIN_RTT_REDUCTION = 1,   // 'BBQ7'
+    INFLIGHT_REDUCTION = 2,  // 'BBQ8'
+    CWND_REDUCTION = 3,      // 'BBQ9'
+  };
+
+  // Different modes change bandwidth_lo_ differently upon loss.
+  QuicBandwidthLoMode bw_lo_mode_ = QuicBandwidthLoMode::DEFAULT;
+
+  // Set the pacing gain to 25% larger than the recent BW increase in STARTUP.
+  bool decrease_startup_pacing_at_end_of_round = false;
+
+  // Latch the flag for quic_bbr2_bw_startup.
+  const bool bw_startup = GetQuicReloadableFlag(quic_bbr2_bw_startup);
 };
 
 class QUIC_EXPORT_PRIVATE RoundTripCounter {
diff --git a/quic/core/congestion_control/bbr2_sender.cc b/quic/core/congestion_control/bbr2_sender.cc
index c12c4e2..b27196b 100644
--- a/quic/core/congestion_control/bbr2_sender.cc
+++ b/quic/core/congestion_control/bbr2_sender.cc
@@ -133,6 +133,9 @@
   if (ContainsQuicTag(connection_options, kBBQ2)) {
     params_.startup_cwnd_gain = 2.885;
     params_.drain_cwnd_gain = 2.885;
+    if (params_.bw_startup) {
+      model_.set_cwnd_gain(params_.startup_cwnd_gain);
+    }
   }
   if (ContainsQuicTag(connection_options, kB2NE)) {
     params_.always_exit_startup_on_excess_loss = false;
@@ -156,6 +159,22 @@
   if (ContainsQuicTag(connection_options, kBSAO)) {
     model_.EnableOverestimateAvoidance();
   }
+  if (params_.bw_startup && ContainsQuicTag(connection_options, kBBQ6)) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_bbr2_bw_startup, 1, 4);
+    params_.decrease_startup_pacing_at_end_of_round = true;
+  }
+  if (params_.bw_startup && ContainsQuicTag(connection_options, kBBQ7)) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_bbr2_bw_startup, 2, 4);
+    params_.bw_lo_mode_ = Bbr2Params::QuicBandwidthLoMode::MIN_RTT_REDUCTION;
+  }
+  if (params_.bw_startup && ContainsQuicTag(connection_options, kBBQ8)) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_bbr2_bw_startup, 3, 4);
+    params_.bw_lo_mode_ = Bbr2Params::QuicBandwidthLoMode::INFLIGHT_REDUCTION;
+  }
+  if (params_.bw_startup && ContainsQuicTag(connection_options, kBBQ9)) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_bbr2_bw_startup, 4, 4);
+    params_.bw_lo_mode_ = Bbr2Params::QuicBandwidthLoMode::CWND_REDUCTION;
+  }
 }
 
 Limits<QuicByteCount> Bbr2Sender::GetCwndLimitsByMode() const {
@@ -303,11 +322,14 @@
   }
 
   QuicBandwidth target_rate = model_.pacing_gain() * model_.BandwidthEstimate();
-  if (model_.full_bandwidth_reached()) {
+  if (model_.full_bandwidth_reached() ||
+      params_.decrease_startup_pacing_at_end_of_round ||
+      params_.bw_lo_mode_ != Bbr2Params::DEFAULT) {
     pacing_rate_ = target_rate;
     return;
   }
 
+  // By default, the pacing rate never decreases in STARTUP.
   if (target_rate > pacing_rate_) {
     pacing_rate_ = target_rate;
   }
diff --git a/quic/core/congestion_control/bbr2_simulator_test.cc b/quic/core/congestion_control/bbr2_simulator_test.cc
index 5aec9cb..f681650 100644
--- a/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -121,7 +121,11 @@
 
 class Bbr2SimulatorTest : public QuicTest {
  protected:
-  Bbr2SimulatorTest() : simulator_(&random_) {}
+  Bbr2SimulatorTest() : simulator_(&random_) {
+    // Enable this for all tests because it moves where cwnd and pacing gain
+    // are initialized.
+    SetQuicReloadableFlag(quic_bbr2_bw_startup, true);
+  }
 
   void SetUp() override {
     if (GetQuicFlag(FLAGS_quic_bbr2_test_regression_mode) == "regress") {
@@ -583,7 +587,72 @@
   CreateNetwork(params);
 
   DriveOutOfStartup(params);
-  EXPECT_LE(sender_loss_rate_in_packets(), 0.20);
+  // Packet loss is smaller with a CWND gain of 2 than 2.889.
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.05);
+}
+
+// Test the number of losses decreases with packet-conservation pacing.
+TEST_F(Bbr2DefaultTopologyTest, PacketLossBBQ6SmallBufferStartup) {
+  SetQuicReloadableFlag(quic_bbr2_bw_startup, true);
+  SetConnectionOption(kBBQ2);  // Increase CWND gain.
+  SetConnectionOption(kBBQ6);
+  DefaultTopologyParams params;
+  params.switch_queue_capacity_in_bdp = 0.5;
+  CreateNetwork(params);
+
+  DriveOutOfStartup(params);
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.0575);
+  // bandwidth_lo is cleared exiting STARTUP.
+  EXPECT_EQ(sender_->ExportDebugState().bandwidth_lo,
+            QuicBandwidth::Infinite());
+}
+
+// Test the number of losses decreases with min_rtt packet-conservation pacing.
+TEST_F(Bbr2DefaultTopologyTest, PacketLossBBQ7SmallBufferStartup) {
+  SetQuicReloadableFlag(quic_bbr2_bw_startup, true);
+  SetConnectionOption(kBBQ2);  // Increase CWND gain.
+  SetConnectionOption(kBBQ7);
+  DefaultTopologyParams params;
+  params.switch_queue_capacity_in_bdp = 0.5;
+  CreateNetwork(params);
+
+  DriveOutOfStartup(params);
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.06);
+  // bandwidth_lo is cleared exiting STARTUP.
+  EXPECT_EQ(sender_->ExportDebugState().bandwidth_lo,
+            QuicBandwidth::Infinite());
+}
+
+// Test the number of losses decreases with Inflight packet-conservation pacing.
+TEST_F(Bbr2DefaultTopologyTest, PacketLossBBQ8SmallBufferStartup) {
+  SetQuicReloadableFlag(quic_bbr2_bw_startup, true);
+  SetConnectionOption(kBBQ2);  // Increase CWND gain.
+  SetConnectionOption(kBBQ8);
+  DefaultTopologyParams params;
+  params.switch_queue_capacity_in_bdp = 0.5;
+  CreateNetwork(params);
+
+  DriveOutOfStartup(params);
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.065);
+  // bandwidth_lo is cleared exiting STARTUP.
+  EXPECT_EQ(sender_->ExportDebugState().bandwidth_lo,
+            QuicBandwidth::Infinite());
+}
+
+// Test the number of losses decreases with CWND packet-conservation pacing.
+TEST_F(Bbr2DefaultTopologyTest, PacketLossBBQ9SmallBufferStartup) {
+  SetQuicReloadableFlag(quic_bbr2_bw_startup, true);
+  SetConnectionOption(kBBQ2);  // Increase CWND gain.
+  SetConnectionOption(kBBQ9);
+  DefaultTopologyParams params;
+  params.switch_queue_capacity_in_bdp = 0.5;
+  CreateNetwork(params);
+
+  DriveOutOfStartup(params);
+  EXPECT_LE(sender_loss_rate_in_packets(), 0.065);
+  // bandwidth_lo is cleared exiting STARTUP.
+  EXPECT_EQ(sender_->ExportDebugState().bandwidth_lo,
+            QuicBandwidth::Infinite());
 }
 
 // Verify the behavior of the algorithm in the case when the connection sends
diff --git a/quic/core/congestion_control/bbr2_startup.cc b/quic/core/congestion_control/bbr2_startup.cc
index 5d02de7..9486eb1 100644
--- a/quic/core/congestion_control/bbr2_startup.cc
+++ b/quic/core/congestion_control/bbr2_startup.cc
@@ -8,6 +8,7 @@
 #include "net/third_party/quiche/src/quic/core/congestion_control/bbr2_sender.h"
 #include "net/third_party/quiche/src/quic/core/quic_bandwidth.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 
 namespace quic {
@@ -22,6 +23,11 @@
   sender_->connection_stats_->slowstart_count = 1;
   sender_->connection_stats_->slowstart_duration = QuicTimeAccumulator();
   sender_->connection_stats_->slowstart_duration.Start(now);
+  if (sender->Params().bw_startup) {
+    // Enter() is never called for Startup, so the gains needs to be set here.
+    model_->set_pacing_gain(Params().startup_pacing_gain);
+    model_->set_cwnd_gain(Params().startup_cwnd_gain);
+  }
 }
 
 void Bbr2StartupMode::Enter(QuicTime /*now*/,
@@ -32,6 +38,8 @@
 void Bbr2StartupMode::Leave(QuicTime now,
                             const Bbr2CongestionEvent* /*congestion_event*/) {
   sender_->connection_stats_->slowstart_duration.Stop(now);
+  // Clear bandwidth_lo if it's set during STARTUP.
+  model_->clear_bandwidth_lo();
 }
 
 Bbr2Mode Bbr2StartupMode::OnCongestionEvent(
@@ -50,8 +58,42 @@
     }
   }
 
-  model_->set_pacing_gain(Params().startup_pacing_gain);
-  model_->set_cwnd_gain(Params().startup_cwnd_gain);
+  if (Params().decrease_startup_pacing_at_end_of_round) {
+    DCHECK_GT(model_->pacing_gain(), 0);
+    DCHECK(Params().bw_startup);
+    if (congestion_event.end_of_round_trip &&
+        !congestion_event.last_sample_is_app_limited) {
+      // Multiply by startup_pacing_gain, so if the bandwidth doubles,
+      // the pacing gain will be the full startup_pacing_gain.
+      if (max_bw_at_round_beginning_ > QuicBandwidth::Zero()) {
+        const float bandwidth_ratio =
+            std::max(1., model_->MaxBandwidth().ToBitsPerSecond() /
+                             static_cast<double>(
+                                 max_bw_at_round_beginning_.ToBitsPerSecond()));
+        // Even when bandwidth isn't increasing, use a gain large enough to
+        // cause a startup_full_bw_threshold increase.
+        const float new_gain =
+            ((bandwidth_ratio - 1) * (Params().startup_pacing_gain -
+                                      Params().startup_full_bw_threshold)) +
+            Params().startup_full_bw_threshold;
+        // Allow the pacing gain to decrease.
+        model_->set_pacing_gain(
+            std::min(Params().startup_pacing_gain, new_gain));
+        // Clear bandwidth_lo if it's less than the pacing rate.
+        // This avoids a constantly app-limited flow from having it's pacing
+        // gain effectively decreased below 1.25.
+        if (model_->bandwidth_lo() <
+            model_->MaxBandwidth() * model_->pacing_gain()) {
+          model_->clear_bandwidth_lo();
+        }
+      }
+      max_bw_at_round_beginning_ = model_->MaxBandwidth();
+    }
+  } else if (!Params().bw_startup) {
+    // When the flag is enabled, set these in the constructor.
+    model_->set_pacing_gain(Params().startup_pacing_gain);
+    model_->set_cwnd_gain(Params().startup_cwnd_gain);
+  }
 
   // TODO(wub): Maybe implement STARTUP => PROBE_RTT.
   return model_->full_bandwidth_reached() ? Bbr2Mode::DRAIN : Bbr2Mode::STARTUP;
diff --git a/quic/core/congestion_control/bbr2_startup.h b/quic/core/congestion_control/bbr2_startup.h
index f753a1e..6b44ae8 100644
--- a/quic/core/congestion_control/bbr2_startup.h
+++ b/quic/core/congestion_control/bbr2_startup.h
@@ -57,6 +57,8 @@
   const Bbr2Params& Params() const;
 
   void CheckExcessiveLosses(const Bbr2CongestionEvent& congestion_event);
+  // Used when the pacing gain can decrease in STARTUP.
+  QuicBandwidth max_bw_at_round_beginning_ = QuicBandwidth::Zero();
 };
 
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index d0420cc..acf44a4 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -108,6 +108,14 @@
 const QuicTag kBBQ5 = TAG('B', 'B', 'Q', '5');   // Expire ack aggregation upon
                                                  // bandwidth increase in
                                                  // STARTUP.
+const QuicTag kBBQ6 = TAG('B', 'B', 'Q', '6');   // Reduce STARTUP gain to 25%
+                                                 // more than BW increase.
+const QuicTag kBBQ7 = TAG('B', 'B', 'Q', '7');   // Reduce bw_lo by
+                                                 // bytes_lost/min_rtt.
+const QuicTag kBBQ8 = TAG('B', 'B', 'Q', '8');   // Reduce bw_lo by
+                                                 // bw_lo * bytes_lost/inflight
+const QuicTag kBBQ9 = TAG('B', 'B', 'Q', '9');   // Reduce bw_lo by
+                                                 // bw_lo * bytes_lost/cwnd
 const QuicTag kRENO = TAG('R', 'E', 'N', 'O');   // Reno Congestion Control
 const QuicTag kTPCC = TAG('P', 'C', 'C', '\0');  // Performance-Oriented
                                                  // Congestion Control
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 50b6c9e..912455f 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -11,6 +11,7 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_allocate_stream_sequencer_buffer_blocks_on_demand, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_allow_client_enabled_bbr_v2, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_avoid_too_low_probe_bw_cwnd, false)
+QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_bw_startup, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_disable_reno_coexistence, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_fewer_startup_round_trips, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_use_bytes_delivered, false)