diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index a69dc33..e59aa8d 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -10,6 +10,7 @@
 
 #include "net/third_party/quiche/src/quic/core/congestion_control/rtt_stats.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
@@ -77,14 +78,17 @@
 
 BbrSender::DebugState::DebugState(const DebugState& state) = default;
 
-BbrSender::BbrSender(const RttStats* rtt_stats,
+BbrSender::BbrSender(QuicTime now,
+                     const RttStats* rtt_stats,
                      const QuicUnackedPacketMap* unacked_packets,
                      QuicPacketCount initial_tcp_congestion_window,
                      QuicPacketCount max_tcp_congestion_window,
-                     QuicRandom* random)
+                     QuicRandom* random,
+                     QuicConnectionStats* stats)
     : rtt_stats_(rtt_stats),
       unacked_packets_(unacked_packets),
       random_(random),
+      stats_(stats),
       mode_(STARTUP),
       round_trip_count_(0),
       max_bandwidth_(kBandwidthWindowSize, QuicBandwidth::Zero(), 0),
@@ -134,7 +138,11 @@
       probe_rtt_disabled_if_app_limited_(false),
       app_limited_since_last_probe_rtt_(false),
       min_rtt_since_last_probe_rtt_(QuicTime::Delta::Infinite()) {
-  EnterStartupMode();
+  if (stats_) {
+    stats_->slowstart_count = 0;
+    stats_->slowstart_start_time = QuicTime::Zero();
+  }
+  EnterStartupMode(now);
 }
 
 BbrSender::~BbrSender() {}
@@ -156,6 +164,11 @@
                              QuicPacketNumber packet_number,
                              QuicByteCount bytes,
                              HasRetransmittableData is_retransmittable) {
+  if (stats_ && InSlowStart()) {
+    ++stats_->slowstart_packets_sent;
+    stats_->slowstart_bytes_sent += bytes;
+  }
+
   last_sent_packet_ = packet_number;
 
   if (bytes_in_flight == 0 && sampler_.is_app_limited()) {
@@ -425,7 +438,12 @@
   return min_congestion_window_;
 }
 
-void BbrSender::EnterStartupMode() {
+void BbrSender::EnterStartupMode(QuicTime now) {
+  if (stats_) {
+    ++stats_->slowstart_count;
+    DCHECK_EQ(stats_->slowstart_start_time, QuicTime::Zero()) << mode_;
+    stats_->slowstart_start_time = now;
+  }
   mode_ = STARTUP;
   pacing_gain_ = high_gain_;
   congestion_window_gain_ = high_cwnd_gain_;
@@ -450,8 +468,14 @@
 void BbrSender::DiscardLostPackets(const LostPacketVector& lost_packets) {
   for (const LostPacket& packet : lost_packets) {
     sampler_.OnPacketLost(packet.packet_number);
-    if (startup_rate_reduction_multiplier_ != 0 && mode_ == STARTUP) {
-      startup_bytes_lost_ += packet.bytes_lost;
+    if (mode_ == STARTUP) {
+      if (stats_) {
+        ++stats_->slowstart_packets_lost;
+        stats_->slowstart_bytes_lost += packet.bytes_lost;
+      }
+      if (startup_rate_reduction_multiplier_ != 0) {
+        startup_bytes_lost_ += packet.bytes_lost;
+      }
     }
   }
 }
@@ -461,6 +485,9 @@
       last_acked_packet > current_round_trip_end_) {
     round_trip_count_++;
     current_round_trip_end_ = last_sent_packet_;
+    if (stats_ && InSlowStart()) {
+      ++stats_->slowstart_num_rtts;
+    }
     return true;
   }
 
@@ -603,6 +630,7 @@
 
 void BbrSender::MaybeExitStartupOrDrain(QuicTime now) {
   if (mode_ == STARTUP && is_at_full_bandwidth_) {
+    OnExitStartup(now);
     mode_ = DRAIN;
     pacing_gain_ = drain_gain_;
     congestion_window_gain_ = high_cwnd_gain_;
@@ -613,10 +641,25 @@
   }
 }
 
+void BbrSender::OnExitStartup(QuicTime now) {
+  DCHECK_EQ(mode_, STARTUP);
+  if (stats_) {
+    DCHECK_NE(stats_->slowstart_start_time, QuicTime::Zero());
+    if (now > stats_->slowstart_start_time) {
+      stats_->slowstart_duration =
+          now - stats_->slowstart_start_time + stats_->slowstart_duration;
+    }
+    stats_->slowstart_start_time = QuicTime::Zero();
+  }
+}
+
 void BbrSender::MaybeEnterOrExitProbeRtt(QuicTime now,
                                          bool is_round_start,
                                          bool min_rtt_expired) {
   if (min_rtt_expired && !exiting_quiescence_ && mode_ != PROBE_RTT) {
+    if (InSlowStart()) {
+      OnExitStartup(now);
+    }
     mode_ = PROBE_RTT;
     pacing_gain_ = 1;
     // Do not decide on the time to exit PROBE_RTT until the |bytes_in_flight|
@@ -644,7 +687,7 @@
       if (now >= exit_probe_rtt_at_ && probe_rtt_round_passed_) {
         min_rtt_timestamp_ = now;
         if (!is_at_full_bandwidth_) {
-          EnterStartupMode();
+          EnterStartupMode(now);
         } else {
           EnterProbeBandwidthMode(now);
         }
diff --git a/quic/core/congestion_control/bbr_sender.h b/quic/core/congestion_control/bbr_sender.h
index cae47f9..405300f 100644
--- a/quic/core/congestion_control/bbr_sender.h
+++ b/quic/core/congestion_control/bbr_sender.h
@@ -88,11 +88,13 @@
     QuicPacketNumber end_of_app_limited_phase;
   };
 
-  BbrSender(const RttStats* rtt_stats,
+  BbrSender(QuicTime now,
+            const RttStats* rtt_stats,
             const QuicUnackedPacketMap* unacked_packets,
             QuicPacketCount initial_tcp_congestion_window,
             QuicPacketCount max_tcp_congestion_window,
-            QuicRandom* random);
+            QuicRandom* random,
+            QuicConnectionStats* stats);
   BbrSender(const BbrSender&) = delete;
   BbrSender& operator=(const BbrSender&) = delete;
   ~BbrSender() override;
@@ -192,7 +194,7 @@
   bool ShouldExtendMinRttExpiry() const;
 
   // Enters the STARTUP mode.
-  void EnterStartupMode();
+  void EnterStartupMode(QuicTime now);
   // Enters the PROBE_BW mode.
   void EnterProbeBandwidthMode(QuicTime now);
 
@@ -236,7 +238,7 @@
   // Determines the appropriate congestion window for the connection.
   void CalculateCongestionWindow(QuicByteCount bytes_acked,
                                  QuicByteCount excess_acked);
-  // Determines the approriate window that constrains the in-flight during
+  // Determines the appropriate window that constrains the in-flight during
   // recovery.
   void CalculateRecoveryWindow(QuicByteCount bytes_acked,
                                QuicByteCount bytes_lost);
@@ -245,9 +247,13 @@
   // will be observed if present.
   bool IsPipeSufficientlyFull() const;
 
+  // Called right before exiting STARTUP.
+  void OnExitStartup(QuicTime now);
+
   const RttStats* rtt_stats_;
   const QuicUnackedPacketMap* unacked_packets_;
   QuicRandom* random_;
+  QuicConnectionStats* stats_;
 
   Mode mode_;
 
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index 205cf65..4de237f 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -23,6 +23,10 @@
 #include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/switch.h"
 
+using testing::AllOf;
+using testing::Ge;
+using testing::Le;
+
 namespace quic {
 namespace test {
 
@@ -127,11 +131,11 @@
         endpoint->connection()->sent_packet_manager().GetRttStats();
     // Ownership of the sender will be overtaken by the endpoint.
     BbrSender* sender = new BbrSender(
-        rtt_stats,
+        endpoint->connection()->clock()->Now(), rtt_stats,
         QuicSentPacketManagerPeer::GetUnackedPacketMap(
             QuicConnectionPeer::GetSentPacketManager(endpoint->connection())),
         kInitialCongestionWindowPackets, kDefaultMaxCongestionWindowPackets,
-        &random_);
+        &random_, QuicConnectionPeer::GetStats(endpoint->connection()));
     QuicConnectionPeer::SetSendAlgorithm(endpoint->connection(), sender);
     endpoint->RecordTrace();
     return sender;
@@ -367,11 +371,11 @@
   // Decrease the CWND gain so extra CWND is required with stretch acks.
   FLAGS_quic_bbr_cwnd_gain = 1.0;
   sender_ = new BbrSender(
-      rtt_stats_,
+      bbr_sender_.connection()->clock()->Now(), rtt_stats_,
       QuicSentPacketManagerPeer::GetUnackedPacketMap(
           QuicConnectionPeer::GetSentPacketManager(bbr_sender_.connection())),
       kInitialCongestionWindowPackets, kDefaultMaxCongestionWindowPackets,
-      &random_);
+      &random_, QuicConnectionPeer::GetStats(bbr_sender_.connection()));
   QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(), sender_);
   // Enable Ack Decimation on the receiver.
   QuicConnectionPeer::SetAckMode(receiver_.connection(),
@@ -1310,5 +1314,27 @@
   EXPECT_GE(sender_->ExportDebugState().min_rtt_timestamp, probe_rtt_start);
 }
 
+TEST_F(BbrSenderTest, StartupStats) {
+  CreateDefaultSetup();
+
+  DriveOutOfStartup();
+  ASSERT_FALSE(sender_->InSlowStart());
+
+  const QuicConnectionStats& stats = bbr_sender_.connection()->GetStats();
+  EXPECT_EQ(1, stats.slowstart_count);
+  EXPECT_THAT(stats.slowstart_num_rtts, AllOf(Ge(5), Le(15)));
+  EXPECT_THAT(stats.slowstart_packets_sent, AllOf(Ge(100), Le(1000)));
+  EXPECT_THAT(stats.slowstart_bytes_sent, AllOf(Ge(1e5), Le(1e6)));
+  EXPECT_LE(stats.slowstart_packets_lost, 10);
+  EXPECT_LE(stats.slowstart_bytes_lost, 1e4);
+  EXPECT_THAT(stats.slowstart_duration,
+              AllOf(Ge(QuicTime::Delta::FromMilliseconds(500)),
+                    Le(QuicTime::Delta::FromMilliseconds(1500))));
+  EXPECT_EQ(QuicTime::Zero(), stats.slowstart_start_time);
+  EXPECT_EQ(stats.slowstart_duration,
+            QuicConnectionPeer::GetSentPacketManager(bbr_sender_.connection())
+                ->GetSlowStartDuration());
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/congestion_control/send_algorithm_interface.cc b/quic/core/congestion_control/send_algorithm_interface.cc
index 07efa43..0b3c6c8 100644
--- a/quic/core/congestion_control/send_algorithm_interface.cc
+++ b/quic/core/congestion_control/send_algorithm_interface.cc
@@ -30,9 +30,9 @@
   switch (congestion_control_type) {
     case kGoogCC:  // GoogCC is not supported by quic/core, fall back to BBR.
     case kBBR:
-      return new BbrSender(rtt_stats, unacked_packets,
+      return new BbrSender(clock->ApproximateNow(), rtt_stats, unacked_packets,
                            initial_congestion_window, max_congestion_window,
-                           random);
+                           random, stats);
     case kPCC:
       if (GetQuicReloadableFlag(quic_enable_pcc3)) {
         return CreatePccSender(clock, rtt_stats, unacked_packets, random, stats,
diff --git a/quic/core/quic_connection_stats.cc b/quic/core/quic_connection_stats.cc
index 5dea2ea..4d5c578 100644
--- a/quic/core/quic_connection_stats.cc
+++ b/quic/core/quic_connection_stats.cc
@@ -20,9 +20,14 @@
       bytes_spuriously_retransmitted(0),
       packets_spuriously_retransmitted(0),
       packets_lost(0),
+      slowstart_count(0),
+      slowstart_num_rtts(0),
       slowstart_packets_sent(0),
+      slowstart_bytes_sent(0),
       slowstart_packets_lost(0),
       slowstart_bytes_lost(0),
+      slowstart_duration(QuicTime::Delta::Zero()),
+      slowstart_start_time(QuicTime::Zero()),
       packets_dropped(0),
       crypto_retransmit_count(0),
       loss_timeout_count(0),
diff --git a/quic/core/quic_connection_stats.h b/quic/core/quic_connection_stats.h
index 8123fb0..df2f7f8 100644
--- a/quic/core/quic_connection_stats.h
+++ b/quic/core/quic_connection_stats.h
@@ -48,12 +48,22 @@
   // Number of packets abandoned as lost by the loss detection algorithm.
   QuicPacketCount packets_lost;
 
+  // Number of times this connection went through the slow start phase.
+  uint32_t slowstart_count;
+  // Number of round trips spent in slow start.
+  uint32_t slowstart_num_rtts;
   // Number of packets sent in slow start.
   QuicPacketCount slowstart_packets_sent;
+  // Number of bytes sent in slow start.
+  QuicByteCount slowstart_bytes_sent;
   // Number of packets lost exiting slow start.
   QuicPacketCount slowstart_packets_lost;
   // Number of bytes lost exiting slow start.
   QuicByteCount slowstart_bytes_lost;
+  // Time spent in COMPLETED slow start phases.
+  QuicTime::Delta slowstart_duration;
+  // Start time of the last slow start phase.
+  QuicTime slowstart_start_time;
 
   QuicPacketCount packets_dropped;  // Duplicate or less than least unacked.
   size_t crypto_retransmit_count;
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 72c5c0f..89757de 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -13,6 +13,7 @@
 #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_stats.h"
 #include "net/third_party/quiche/src/quic/core/quic_pending_retransmission.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
@@ -1014,6 +1015,19 @@
   return retransmission_delay;
 }
 
+QuicTime::Delta QuicSentPacketManager::GetSlowStartDuration() const {
+  if (send_algorithm_->GetCongestionControlType() != kBBR) {
+    return QuicTime::Delta::Infinite();
+  }
+
+  if (!send_algorithm_->InSlowStart()) {
+    return stats_->slowstart_duration;
+  }
+
+  return clock_->ApproximateNow() - stats_->slowstart_start_time +
+         stats_->slowstart_duration;
+}
+
 std::string QuicSentPacketManager::GetDebugState() const {
   return send_algorithm_->GetDebugState();
 }
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 4310014..c3c227e 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -235,6 +235,14 @@
     return send_algorithm_->GetSlowStartThreshold() / kDefaultTCPMSS;
   }
 
+  // Return the total time spent in slow start so far. If the sender is
+  // currently in slow start, the return value will include the duration between
+  // the most recent entry to slow start and now.
+  //
+  // Only implemented for BBR. Return QuicTime::Delta::Infinite() for other
+  // congestion controllers.
+  QuicTime::Delta GetSlowStartDuration() const;
+
   // Returns debugging information about the state of the congestion controller.
   std::string GetDebugState() const;
 
diff --git a/quic/core/quic_time.h b/quic/core/quic_time.h
index c8a1c84..cd33649 100644
--- a/quic/core/quic_time.h
+++ b/quic/core/quic_time.h
@@ -234,6 +234,12 @@
   return !(lhs < rhs);
 }
 
+// Override stream output operator for gtest or CHECK macros.
+inline std::ostream& operator<<(std::ostream& output, const QuicTime t) {
+  output << t.ToDebuggingValue();
+  return output;
+}
+
 // Non-member arithmetic operators for QuicTime::Delta.
 inline QuicTime::Delta operator+(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return QuicTime::Delta(lhs.time_offset_ + rhs.time_offset_);