diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index d4ba114..ed1fac4 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -308,10 +308,7 @@
       perspective_(perspective),
       connected_(true),
       can_truncate_connection_ids_(perspective == Perspective::IS_SERVER),
-      mtu_discovery_target_(0),
       mtu_probe_count_(0),
-      packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
-      next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       write_error_occurred_(false),
       no_stop_waiting_frames_(
@@ -336,7 +333,6 @@
       treat_queued_packets_as_sent_(
           GetQuicReloadableFlag(quic_treat_queued_packets_as_sent) ||
           version().CanSendCoalescedPackets()),
-      mtu_discovery_v2_(GetQuicReloadableFlag(quic_mtu_discovery_v2)),
       quic_version_negotiated_by_default_at_server_(
           GetQuicReloadableFlag(quic_version_negotiated_by_default_at_server)),
       use_handshake_delegate_(
@@ -2376,17 +2372,13 @@
   // In some cases, an MTU probe can cause EMSGSIZE. This indicates that the
   // MTU discovery is permanently unsuccessful.
   if (IsMsgTooBig(result) && looks_like_mtu_probe) {
-    if (mtu_discovery_v2_) {
-      // When MSG_TOO_BIG is returned, the system typically knows what the
-      // actual MTU is, so there is no need to probe further.
-      // TODO(wub): Reduce max packet size to a safe default, or the actual MTU.
-      QUIC_DVLOG(1) << ENDPOINT << " MTU probe packet too big, size:"
-                    << packet->encrypted_length
-                    << ", long_term_mtu_:" << long_term_mtu_;
-      mtu_discoverer_.Disable();
-    } else {
-      mtu_discovery_target_ = 0;
-    }
+    // When MSG_TOO_BIG is returned, the system typically knows what the
+    // actual MTU is, so there is no need to probe further.
+    // TODO(wub): Reduce max packet size to a safe default, or the actual MTU.
+    QUIC_DVLOG(1) << ENDPOINT << " MTU probe packet too big, size:"
+                  << packet->encrypted_length
+                  << ", long_term_mtu_:" << long_term_mtu_;
+    mtu_discoverer_.Disable();
     mtu_discovery_alarm_->Cancel();
     // The write failed, but the writer is not blocked, so return true.
     return true;
@@ -2612,10 +2604,8 @@
   if (packet_size > max_packet_length()) {
     const QuicByteCount old_max_packet_length = max_packet_length();
     SetMaxPacketLength(packet_size);
-    if (mtu_discovery_v2_) {
-      mtu_discoverer_.OnMaxPacketLengthUpdated(old_max_packet_length,
-                                               max_packet_length());
-    }
+    mtu_discoverer_.OnMaxPacketLengthUpdated(old_max_packet_length,
+                                             max_packet_length());
   }
 }
 
@@ -3279,35 +3269,11 @@
 }
 
 void QuicConnection::MaybeSetMtuAlarm(QuicPacketNumber sent_packet_number) {
-  if (mtu_discovery_v2_) {
-    if (mtu_discovery_alarm_->IsSet() ||
-        !mtu_discoverer_.ShouldProbeMtu(sent_packet_number)) {
-      return;
-    }
-    mtu_discovery_alarm_->Set(clock_->ApproximateNow());
+  if (mtu_discovery_alarm_->IsSet() ||
+      !mtu_discoverer_.ShouldProbeMtu(sent_packet_number)) {
     return;
   }
-
-  // Do not set the alarm if the target size is less than the current size.
-  // This covers the case when |mtu_discovery_target_| is at its default value,
-  // zero.
-  if (mtu_discovery_target_ <= max_packet_length()) {
-    return;
-  }
-
-  if (mtu_probe_count_ >= kMtuDiscoveryAttempts) {
-    return;
-  }
-
-  if (mtu_discovery_alarm_->IsSet()) {
-    return;
-  }
-
-  if (sent_packet_number >= next_mtu_probe_at_) {
-    // Use an alarm to send the MTU probe to ensure that no ScopedPacketFlushers
-    // are active.
-    mtu_discovery_alarm_->Set(clock_->ApproximateNow());
-  }
+  mtu_discovery_alarm_->Set(clock_->ApproximateNow());
 }
 
 void QuicConnection::MaybeSetAckAlarmTo(QuicTime time) {
@@ -3450,13 +3416,8 @@
 
 void QuicConnection::SetMtuDiscoveryTarget(QuicByteCount target) {
   QUIC_DVLOG(2) << ENDPOINT << "SetMtuDiscoveryTarget: " << target;
-  if (mtu_discovery_v2_) {
-    mtu_discoverer_.Disable();
-    mtu_discoverer_.Enable(max_packet_length(),
-                           GetLimitedMaxPacketSize(target));
-  } else {
-    mtu_discovery_target_ = GetLimitedMaxPacketSize(target);
-  }
+  mtu_discoverer_.Disable();
+  mtu_discoverer_.Enable(max_packet_length(), GetLimitedMaxPacketSize(target));
 }
 
 QuicByteCount QuicConnection::GetLimitedMaxPacketSize(
@@ -3625,35 +3586,13 @@
 void QuicConnection::DiscoverMtu() {
   DCHECK(!mtu_discovery_alarm_->IsSet());
 
-  if (mtu_discovery_v2_) {
-    const QuicPacketNumber largest_sent_packet =
-        sent_packet_manager_.GetLargestSentPacket();
-    if (mtu_discoverer_.ShouldProbeMtu(largest_sent_packet)) {
-      ++mtu_probe_count_;
-      SendMtuDiscoveryPacket(
-          mtu_discoverer_.GetUpdatedMtuProbeSize(largest_sent_packet));
-    }
-    DCHECK(!mtu_discovery_alarm_->IsSet());
-    return;
+  const QuicPacketNumber largest_sent_packet =
+      sent_packet_manager_.GetLargestSentPacket();
+  if (mtu_discoverer_.ShouldProbeMtu(largest_sent_packet)) {
+    ++mtu_probe_count_;
+    SendMtuDiscoveryPacket(
+        mtu_discoverer_.GetUpdatedMtuProbeSize(largest_sent_packet));
   }
-
-  // Check if the MTU has been already increased.
-  if (mtu_discovery_target_ <= max_packet_length()) {
-    return;
-  }
-
-  // Calculate the packet number of the next probe *before* sending the current
-  // one.  Otherwise, when SendMtuDiscoveryPacket() is called,
-  // MaybeSetMtuAlarm() will not realize that the probe has been just sent, and
-  // will reschedule this probe again.
-  packets_between_mtu_probes_ *= 2;
-  next_mtu_probe_at_ = sent_packet_manager_.GetLargestSentPacket() +
-                       packets_between_mtu_probes_ + 1;
-  ++mtu_probe_count_;
-
-  QUIC_DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
-  SendMtuDiscoveryPacket(mtu_discovery_target_);
-
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index a99f401..2fcc604 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -747,8 +747,7 @@
   virtual void SendConnectivityProbingResponsePacket(
       const QuicSocketAddress& peer_address);
 
-  // Sends an MTU discovery packet of size |mtu_discovery_target_| and updates
-  // the MTU discovery alarm.
+  // Sends an MTU discovery packet and updates the MTU discovery alarm.
   void DiscoverMtu();
 
   // Sets the session notifier on the SentPacketManager.
@@ -1409,19 +1408,9 @@
   // version negotiation packet.
   ParsedQuicVersionVector server_supported_versions_;
 
-  // The size of the packet we are targeting while doing path MTU discovery.
-  QuicByteCount mtu_discovery_target_;
-
   // The number of MTU probes already sent.
   size_t mtu_probe_count_;
 
-  // The number of packets between MTU probes.
-  QuicPacketCount packets_between_mtu_probes_;
-
-  // The packet number of the packet after which the next MTU probe will be
-  // sent.
-  QuicPacketNumber next_mtu_probe_at_;
-
   // The value of the MTU regularly used by the connection. This is different
   // from the value returned by max_packet_size(), as max_packet_size() returns
   // the value of the MTU as currently used by the serializer, so if
@@ -1533,9 +1522,6 @@
   // Latched value of quic_treat_queued_packets_as_sent.
   const bool treat_queued_packets_as_sent_;
 
-  // Latched value of quic_mtu_discovery_v2.
-  const bool mtu_discovery_v2_;
-  // Only used if quic_mtu_discovery_v2 is true.
   QuicConnectionMtuDiscoverer mtu_discoverer_;
 
   // Latched value of quic_version_negotiated_by_default_at_server.
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index e1a304b..0c6c542 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1566,16 +1566,9 @@
 
   void set_packets_between_probes_base(
       const QuicPacketCount packets_between_probes_base) {
-    if (GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-      QuicConnectionPeer::ReInitializeMtuDiscoverer(
-          &connection_, packets_between_probes_base,
-          QuicPacketNumber(packets_between_probes_base));
-    } else {
-      QuicConnectionPeer::SetPacketsBetweenMtuProbes(
-          &connection_, packets_between_probes_base);
-      QuicConnectionPeer::SetNextMtuProbeAt(
-          &connection_, QuicPacketNumber(packets_between_probes_base));
-    }
+    QuicConnectionPeer::ReInitializeMtuDiscoverer(
+        &connection_, packets_between_probes_base,
+        QuicPacketNumber(packets_between_probes_base));
   }
 
   bool IsDefaultTestConfiguration() {
@@ -4894,12 +4887,9 @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
       .WillOnce(SaveArg<3>(&probe_size));
   connection_.GetMtuDiscoveryAlarm()->Fire();
-  if (GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-    EXPECT_THAT(probe_size, InRange(connection_.max_packet_length(),
-                                    kMtuDiscoveryTargetPacketSizeHigh));
-  } else {
-    EXPECT_EQ(kMtuDiscoveryTargetPacketSizeHigh, probe_size);
-  }
+
+  EXPECT_THAT(probe_size, InRange(connection_.max_packet_length(),
+                                  kMtuDiscoveryTargetPacketSizeHigh));
 
   const QuicPacketNumber probe_packet_number =
       FirstSendingPacketNumber() + packets_between_probes_base;
@@ -4915,17 +4905,6 @@
 
   EXPECT_EQ(1u, connection_.mtu_probe_count());
 
-  if (!GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-    // Send more packets, and ensure that none of them sets the alarm.
-    for (QuicPacketCount i = 0; i < 4 * packets_between_probes_base; i++) {
-      SendStreamDataToPeer(3, ".", packets_between_probes_base + i, NO_FIN,
-                           nullptr);
-      ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
-    }
-
-    return;
-  }
-
   QuicStreamOffset stream_offset = packets_between_probes_base;
   for (size_t num_probes = 1; num_probes < kMtuDiscoveryAttempts;
        ++num_probes) {
@@ -5083,9 +5062,6 @@
 
 // Probe 3 times, the first one succeeds, then fails, then succeeds again.
 TEST_P(QuicConnectionTest, MtuDiscoverySecondProbeFailed) {
-  if (!GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-    return;
-  }
   MtuDiscoveryTestInit();
 
   const QuicPacketCount packets_between_probes_base = 5;
@@ -5198,12 +5174,8 @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
       .WillOnce(SaveArg<3>(&probe_size));
   connection_.GetMtuDiscoveryAlarm()->Fire();
-  if (GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-    EXPECT_THAT(probe_size,
-                InRange(connection_.max_packet_length(), mtu_limit));
-  } else {
-    EXPECT_EQ(mtu_limit, probe_size);
-  }
+
+  EXPECT_THAT(probe_size, InRange(connection_.max_packet_length(), mtu_limit));
 
   const QuicPacketNumber probe_sequence_number =
       FirstSendingPacketNumber() + packets_between_probes_base;
@@ -5219,17 +5191,6 @@
 
   EXPECT_EQ(1u, connection_.mtu_probe_count());
 
-  if (!GetQuicReloadableFlag(quic_mtu_discovery_v2)) {
-    // Send more packets, and ensure that none of them sets the alarm.
-    for (QuicPacketCount i = 0; i < 4 * packets_between_probes_base; i++) {
-      SendStreamDataToPeer(3, ".", packets_between_probes_base + i, NO_FIN,
-                           nullptr);
-      ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
-    }
-
-    return;
-  }
-
   QuicStreamOffset stream_offset = packets_between_probes_base;
   for (size_t num_probes = 1; num_probes < kMtuDiscoveryAttempts;
        ++num_probes) {
diff --git a/quic/core/quic_mtu_discovery.cc b/quic/core/quic_mtu_discovery.cc
index c89b41a..bbf18b6 100644
--- a/quic/core/quic_mtu_discovery.cc
+++ b/quic/core/quic_mtu_discovery.cc
@@ -77,10 +77,8 @@
     // The next probe packet is as big as the previous one. Assuming the
     // previous one exceeded MTU, we need to decrease the probe packet length.
     max_probe_length_ = probe_packet_length;
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_mtu_discovery_v2, 1, 3);
   } else {
     DCHECK_GT(probe_packet_length, last_probe_length_);
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_mtu_discovery_v2, 2, 3);
   }
   last_probe_length_ = next_probe_packet_length();
 
@@ -125,7 +123,6 @@
 
   DCHECK_EQ(old_value, min_probe_length_);
   min_probe_length_ = new_value;
-  QUIC_RELOADABLE_FLAG_COUNT_N(quic_mtu_discovery_v2, 3, 3);
 }
 
 std::ostream& operator<<(std::ostream& os,
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index d48ff05..79fc7e3 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -212,22 +212,7 @@
 // static
 QuicPacketCount QuicConnectionPeer::GetPacketsBetweenMtuProbes(
     QuicConnection* connection) {
-  if (connection->mtu_discovery_v2_) {
-    return connection->mtu_discoverer_.packets_between_probes();
-  }
-  return connection->packets_between_mtu_probes_;
-}
-
-// static
-void QuicConnectionPeer::SetPacketsBetweenMtuProbes(QuicConnection* connection,
-                                                    QuicPacketCount packets) {
-  connection->packets_between_mtu_probes_ = packets;
-}
-
-// static
-void QuicConnectionPeer::SetNextMtuProbeAt(QuicConnection* connection,
-                                           QuicPacketNumber number) {
-  connection->next_mtu_probe_at_ = number;
+  return connection->mtu_discoverer_.packets_between_probes();
 }
 
 // static
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index 8eb1c40..3ded2e0 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -102,10 +102,6 @@
 
   static QuicPacketCount GetPacketsBetweenMtuProbes(QuicConnection* connection);
 
-  static void SetPacketsBetweenMtuProbes(QuicConnection* connection,
-                                         QuicPacketCount packets);
-  static void SetNextMtuProbeAt(QuicConnection* connection,
-                                QuicPacketNumber number);
   static void ReInitializeMtuDiscoverer(
       QuicConnection* connection,
       QuicPacketCount packets_between_probes_base,