diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index df2b458..0cdb5c7 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -128,7 +128,6 @@
 
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams(bool use_tls_handshake) {
-  QuicFlagSaver flags;
   // Divide the versions into buckets in which the intra-frame format
   // is compatible. When clients encounter QUIC version negotiation
   // they simply retransmit all packets using the new version's
@@ -137,7 +136,6 @@
   // handshake protocol). So these tests need to ensure that clients are never
   // attempting to do 0-RTT across incompatible versions. Chromium only
   // supports a single version at a time anyway. :)
-  SetQuicReloadableFlag(quic_supports_tls_handshake, use_tls_handshake);
   ParsedQuicVersionVector all_supported_versions =
       FilterSupportedVersions(AllSupportedVersions());
 
@@ -150,6 +148,9 @@
   ParsedQuicVersionVector version_buckets[3];
 
   for (const ParsedQuicVersion& version : all_supported_versions) {
+    if (!use_tls_handshake && version.handshake_protocol == PROTOCOL_TLS1_3) {
+      continue;
+    }
     if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
       version_buckets[0].push_back(version);
     } else if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
@@ -247,7 +248,6 @@
         stream_factory_(nullptr),
         support_server_push_(false),
         expected_server_connection_id_length_(kQuicDefaultConnectionIdLength) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     client_supported_versions_ = GetParam().client_supported_versions;
     server_supported_versions_ = GetParam().server_supported_versions;
     negotiated_version_ = GetParam().negotiated_version;
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 9e8c749..ddf30fe 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -150,7 +150,6 @@
     handshake_message_ = crypto_config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions());
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     session_->Initialize();
     if (!GetQuicReloadableFlag(quic_version_negotiated_by_default_at_server)) {
       QuicSessionPeer::GetMutableCryptoStream(session_.get())
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 7c4d914..685ffc7 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -84,7 +84,6 @@
             QuicUtils::GetInvalidStreamId(GetParam().transport_version)),
         associated_stream_id_(
             QuicUtils::GetInvalidStreamId(GetParam().transport_version)) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     Initialize();
     // Advance the time, because timers do not like uninitialized times.
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index dd1cade..8c1501e 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -66,7 +66,6 @@
                  connection_,
                  &push_promise_index_),
         body_("hello world") {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     session_.Initialize();
 
     headers_[":status"] = "200";
diff --git a/quic/core/legacy_quic_stream_id_manager_test.cc b/quic/core/legacy_quic_stream_id_manager_test.cc
index 75e381d..6a861a5 100644
--- a/quic/core/legacy_quic_stream_id_manager_test.cc
+++ b/quic/core/legacy_quic_stream_id_manager_test.cc
@@ -21,7 +21,10 @@
 class LegacyQuicStreamIdManagerTest : public QuicTest {
  protected:
   void Initialize(Perspective perspective) {
-    SetQuicReloadableFlag(quic_enable_version_99, false);
+    // LegacyQuicStreamIdManager is only used for versions < 99.
+    // TODO(b/145768765) parameterize this test by version.
+    SetQuicReloadableFlag(quic_enable_version_q099, false);
+    SetQuicReloadableFlag(quic_enable_version_t099, false);
     connection_ = new MockQuicConnection(
         &helper_, &alarm_factory_, perspective,
         ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 3babced..ab5a7ba 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -919,7 +919,6 @@
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   QuicFlagSaver flags;
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
@@ -985,7 +984,6 @@
         notifier_(&connection_),
         connection_close_frame_count_(0) {
     QUIC_DVLOG(2) << "QuicConnectionTest(" << PrintToString(GetParam()) << ")";
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     connection_.set_defer_send_in_response_to_packets(GetParam().ack_response ==
                                                       AckResponse::kDefer);
     framer_.SetInitialObfuscators(TestConnectionId());
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 827cb03..2f758cc 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -61,7 +61,6 @@
   }
 
   void UseTlsHandshake() {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     supported_versions_.clear();
     for (ParsedQuicVersion version : AllSupportedVersions()) {
       if (version.handshake_protocol != PROTOCOL_TLS1_3) {
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 2f7055d..6de5433 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -203,7 +203,6 @@
 }
 
 TEST_P(QuicCryptoServerStreamTest, ConnectedAfterTlsHandshake) {
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   client_options_.only_tls_versions = true;
   supported_versions_.clear();
   for (QuicTransportVersion transport_version :
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 0f78020..51d851d 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -415,12 +415,10 @@
 };
 
 TEST_F(QuicDispatcherTest, TlsClientHelloCreatesSession) {
-  if (!QuicVersionUsesCryptoFrames(
-          CurrentSupportedVersions().front().transport_version)) {
-    // TLS is only supported in versions with crypto frames.
+  if (CurrentSupportedVersions().front().handshake_protocol !=
+      PROTOCOL_TLS1_3) {
     return;
   }
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
   EXPECT_CALL(*dispatcher_,
@@ -438,12 +436,9 @@
   EXPECT_CALL(*dispatcher_,
               ShouldCreateOrBufferPacketForConnection(
                   ReceivedPacketInfoConnectionIdEquals(TestConnectionId(1))));
-  ProcessPacket(
-      client_address, TestConnectionId(1), true,
-      ParsedQuicVersion(PROTOCOL_TLS1_3,
-                        CurrentSupportedVersions().front().transport_version),
-      SerializeCHLO(), true, CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER,
-      1);
+  ProcessPacket(client_address, TestConnectionId(1), true,
+                CurrentSupportedVersions().front(), SerializeCHLO(), true,
+                CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
 }
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
@@ -907,24 +902,26 @@
                 QuicDispatcher::kMaxReasonableInitialPacketNumber);
 }
 
-TEST_F(QuicDispatcherTest, SupportedTransportVersionsChangeInFlight) {
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
-                "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_99, true);
+TEST_F(QuicDispatcherTest, VersionsChangeInFlight) {
+  for (ParsedQuicVersion version : AllSupportedVersions()) {
+    QuicEnableVersion(version);
+  }
+  ASSERT_EQ(AllSupportedVersions(), CurrentSupportedVersions());
 
   VerifyVersionNotSupported(QuicVersionReservedForNegotiation());
 
   VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
                                            QuicVersionMin().transport_version));
-  VerifyVersionSupported(QuicVersionMax());
+  VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
+                                           QuicVersionMax().transport_version));
 
-  // Turn off version 99.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  // Turn off version Q099.
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
   VerifyVersionNotSupported(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
 
-  // Turn on version 99.
-  SetQuicReloadableFlag(quic_enable_version_99, true);
+  // Turn on version Q099.
+  SetQuicReloadableFlag(quic_enable_version_q099, true);
   VerifyVersionSupported(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
 }
@@ -1251,7 +1248,7 @@
 }
 
 TEST_F(QuicDispatcherTest, ProcessSmallCoalescedPacket) {
-  SetQuicReloadableFlag(quic_enable_version_99, true);
+  SetQuicReloadableFlag(quic_enable_version_q099, true);
   CreateTimeWaitListManager();
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
@@ -2063,9 +2060,10 @@
 
 // Regression test for b/117874922.
 TEST_F(BufferedPacketStoreTest, ProcessBufferedChloWithDifferentVersion) {
-  // Turn off version 99, such that the preferred version is not supported by
-  // the server.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  // Turn off versions Q099 and T099, such that the preferred version is not
+  // supported by the server.
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
   uint64_t last_connection_id = kMaxNumSessionsToCreate + 5;
   ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
   for (uint64_t conn_id = 1; conn_id <= last_connection_id; ++conn_id) {
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index ff9653d..13f02bc 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -582,7 +582,6 @@
                 start_,
                 Perspective::IS_SERVER,
                 kQuicDefaultConnectionIdLength) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     framer_.set_version(version_);
     if (framer_.version().KnowsWhichDecrypterToUse()) {
       framer_.InstallDecrypter(ENCRYPTION_INITIAL,
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 95cac21..0f21f01 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -15,8 +15,14 @@
 
 QuicVersionManager::QuicVersionManager(
     ParsedQuicVersionVector supported_versions)
-    : enable_version_99_(GetQuicReloadableFlag(quic_enable_version_99)),
-      enable_tls_(GetQuicReloadableFlag(quic_supports_tls_handshake)),
+    : enable_version_q099_(GetQuicReloadableFlag(quic_enable_version_q099)),
+      enable_version_t099_(GetQuicReloadableFlag(quic_enable_version_t099)),
+      disable_version_q050_(GetQuicReloadableFlag(quic_disable_version_q050)),
+      enable_version_t050_(GetQuicReloadableFlag(quic_enable_version_t050)),
+      disable_version_q049_(GetQuicReloadableFlag(quic_disable_version_q049)),
+      disable_version_q048_(GetQuicReloadableFlag(quic_disable_version_q048)),
+      disable_version_q046_(GetQuicReloadableFlag(quic_disable_version_q046)),
+      disable_version_q043_(GetQuicReloadableFlag(quic_disable_version_q043)),
       allowed_supported_versions_(std::move(supported_versions)) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
@@ -39,10 +45,28 @@
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  if (enable_version_99_ != GetQuicReloadableFlag(quic_enable_version_99) ||
-      enable_tls_ != GetQuicReloadableFlag(quic_supports_tls_handshake)) {
-    enable_version_99_ = GetQuicReloadableFlag(quic_enable_version_99);
-    enable_tls_ = GetQuicReloadableFlag(quic_supports_tls_handshake);
+  if (enable_version_q099_ != GetQuicReloadableFlag(quic_enable_version_q099) ||
+      enable_version_t099_ != GetQuicReloadableFlag(quic_enable_version_t099) ||
+      disable_version_q050_ !=
+          GetQuicReloadableFlag(quic_disable_version_q050) ||
+      enable_version_t050_ != GetQuicReloadableFlag(quic_enable_version_t050) ||
+      disable_version_q049_ !=
+          GetQuicReloadableFlag(quic_disable_version_q049) ||
+      disable_version_q048_ !=
+          GetQuicReloadableFlag(quic_disable_version_q048) ||
+      disable_version_q046_ !=
+          GetQuicReloadableFlag(quic_disable_version_q046) ||
+      disable_version_q043_ !=
+          GetQuicReloadableFlag(quic_disable_version_q043)) {
+    enable_version_q099_ = GetQuicReloadableFlag(quic_enable_version_q099);
+    enable_version_t099_ = GetQuicReloadableFlag(quic_enable_version_t099);
+    disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
+    enable_version_t050_ = GetQuicReloadableFlag(quic_enable_version_t050);
+    disable_version_q049_ = GetQuicReloadableFlag(quic_disable_version_q049);
+    disable_version_q048_ = GetQuicReloadableFlag(quic_disable_version_q048);
+    disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
+    disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
+
     RefilterSupportedVersions();
   }
 }
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index e66e01f..b7aff69 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -41,10 +41,22 @@
 
  private:
   // Cached value of reloadable flags.
-  // quic_enable_version_99 flag
-  bool enable_version_99_;
-  // quic_supports_tls_handshake flag
-  bool enable_tls_;
+  // quic_enable_version_q099 flag
+  bool enable_version_q099_;
+  // quic_enable_version_t099 flag
+  bool enable_version_t099_;
+  // quic_disable_version_q050 flag
+  bool disable_version_q050_;
+  // quic_enable_version_t050 flag
+  bool enable_version_t050_;
+  // quic_disable_version_q049 flag
+  bool disable_version_q049_;
+  // quic_disable_version_q048 flag
+  bool disable_version_q048_;
+  // quic_disable_version_q046 flag
+  bool disable_version_q046_;
+  // quic_disable_version_q043 flag
+  bool disable_version_q043_;
 
   // The list of versions that may be supported.
   ParsedQuicVersionVector allowed_supported_versions_;
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 2abf986..89f15ac 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,8 +18,14 @@
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_99, false);
-  SetQuicReloadableFlag(quic_supports_tls_handshake, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_t050, false);
+  SetQuicReloadableFlag(quic_disable_version_q050, false);
+  SetQuicReloadableFlag(quic_disable_version_q049, false);
+  SetQuicReloadableFlag(quic_disable_version_q048, false);
+  SetQuicReloadableFlag(quic_disable_version_q046, false);
+  SetQuicReloadableFlag(quic_disable_version_q043, false);
   QuicVersionManager manager(AllSupportedVersions());
 
   ParsedQuicVersionVector expected_parsed_versions;
@@ -39,13 +45,27 @@
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
 
-  SetQuicReloadableFlag(quic_enable_version_99, true);
+  SetQuicReloadableFlag(quic_enable_version_q099, true);
   expected_parsed_versions.insert(
       expected_parsed_versions.begin(),
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
+
+  SetQuicReloadableFlag(quic_enable_version_t099, true);
+  expected_parsed_versions.push_back(
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
+  EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
+  EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
+            manager.GetSupportedVersions());
+
+  SetQuicReloadableFlag(quic_enable_version_t050, true);
+  expected_parsed_versions.push_back(
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50));
+  EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
+  EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
+            manager.GetSupportedVersions());
 }
 
 }  // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index f0a943f..b034b16 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -176,13 +176,8 @@
         PROTOCOL_QUIC_CRYPTO,
         static_cast<QuicTransportVersion>(quic_version_number));
   }
-
-  std::vector<HandshakeProtocol> protocols = {PROTOCOL_QUIC_CRYPTO};
-  if (GetQuicReloadableFlag(quic_supports_tls_handshake)) {
-    protocols.push_back(PROTOCOL_TLS1_3);
-  }
   for (QuicTransportVersion version : kSupportedTransportVersions) {
-    for (HandshakeProtocol handshake : protocols) {
+    for (HandshakeProtocol handshake : kSupportedHandshakeProtocols) {
       const ParsedQuicVersion parsed_version =
           ParsedQuicVersion(handshake, version);
       if (version_string == ParsedQuicVersionToString(parsed_version)) {
@@ -191,7 +186,7 @@
     }
   }
   // Still recognize T099 even if flag quic_ietf_draft_version has been changed.
-  if (GetQuicReloadableFlag(quic_supports_tls_handshake) &&
+  if (GetQuicReloadableFlag(quic_enable_version_t099) &&
       version_string == "T099") {
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
   }
@@ -235,12 +230,40 @@
   ParsedQuicVersionVector filtered_versions;
   filtered_versions.reserve(versions.size());
   for (ParsedQuicVersion version : versions) {
-    if (version.handshake_protocol == PROTOCOL_TLS1_3 &&
-        !GetQuicReloadableFlag(quic_supports_tls_handshake)) {
-      continue;
-    }
     if (version.transport_version == QUIC_VERSION_99) {
-      if (GetQuicReloadableFlag(quic_enable_version_99)) {
+      if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+        if (GetQuicReloadableFlag(quic_enable_version_q099)) {
+          filtered_versions.push_back(version);
+        }
+      } else {
+        if (GetQuicReloadableFlag(quic_enable_version_t099)) {
+          filtered_versions.push_back(version);
+        }
+      }
+    } else if (version.transport_version == QUIC_VERSION_50) {
+      if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+        if (!GetQuicReloadableFlag(quic_disable_version_q050)) {
+          filtered_versions.push_back(version);
+        }
+      } else {
+        if (GetQuicReloadableFlag(quic_enable_version_t050)) {
+          filtered_versions.push_back(version);
+        }
+      }
+    } else if (version.transport_version == QUIC_VERSION_49) {
+      if (!GetQuicReloadableFlag(quic_disable_version_q049)) {
+        filtered_versions.push_back(version);
+      }
+    } else if (version.transport_version == QUIC_VERSION_48) {
+      if (!GetQuicReloadableFlag(quic_disable_version_q048)) {
+        filtered_versions.push_back(version);
+      }
+    } else if (version.transport_version == QUIC_VERSION_46) {
+      if (!GetQuicReloadableFlag(quic_disable_version_q046)) {
+        filtered_versions.push_back(version);
+      }
+    } else if (version.transport_version == QUIC_VERSION_43) {
+      if (!GetQuicReloadableFlag(quic_disable_version_q043)) {
         filtered_versions.push_back(version);
       }
     } else {
@@ -432,17 +455,31 @@
 
 void QuicVersionInitializeSupportForIetfDraft() {
   // Enable necessary flags.
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
 }
 
 void QuicEnableVersion(ParsedQuicVersion parsed_version) {
-  if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
-  }
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
   if (parsed_version.transport_version == QUIC_VERSION_99) {
-    SetQuicReloadableFlag(quic_enable_version_99, true);
+    if (parsed_version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+      SetQuicReloadableFlag(quic_enable_version_q099, true);
+    } else {
+      SetQuicReloadableFlag(quic_enable_version_t099, true);
+    }
+  } else if (parsed_version.transport_version == QUIC_VERSION_50) {
+    if (parsed_version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+      SetQuicReloadableFlag(quic_disable_version_q050, false);
+    } else {
+      SetQuicReloadableFlag(quic_enable_version_t050, true);
+    }
+  } else if (parsed_version.transport_version == QUIC_VERSION_49) {
+    SetQuicReloadableFlag(quic_disable_version_q049, false);
+  } else if (parsed_version.transport_version == QUIC_VERSION_48) {
+    SetQuicReloadableFlag(quic_disable_version_q048, false);
+  } else if (parsed_version.transport_version == QUIC_VERSION_46) {
+    SetQuicReloadableFlag(quic_disable_version_q046, false);
+  } else if (parsed_version.transport_version == QUIC_VERSION_43) {
+    SetQuicReloadableFlag(quic_disable_version_q043, false);
   }
 }
 
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 5f2d7ba..56ef26f 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -147,7 +147,6 @@
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q046 "));
 
   // Test a TLS version:
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50),
             ParseQuicVersionString("T050"));
 }
@@ -257,8 +256,15 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_99, true);
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+  SetQuicReloadableFlag(quic_enable_version_q099, true);
+  SetQuicReloadableFlag(quic_enable_version_t099, true);
+  SetQuicReloadableFlag(quic_enable_version_t050, true);
+  SetQuicReloadableFlag(quic_disable_version_q050, false);
+  SetQuicReloadableFlag(quic_disable_version_q049, false);
+  SetQuicReloadableFlag(quic_disable_version_q048, false);
+  SetQuicReloadableFlag(quic_disable_version_q046, false);
+  SetQuicReloadableFlag(quic_disable_version_q043, false);
+
   ParsedQuicVersionVector expected_parsed_versions;
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
@@ -285,8 +291,15 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsNo99) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_99, false);
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_t050, true);
+  SetQuicReloadableFlag(quic_disable_version_q050, false);
+  SetQuicReloadableFlag(quic_disable_version_q049, false);
+  SetQuicReloadableFlag(quic_disable_version_q048, false);
+  SetQuicReloadableFlag(quic_disable_version_q046, false);
+  SetQuicReloadableFlag(quic_disable_version_q043, false);
+
   ParsedQuicVersionVector expected_parsed_versions;
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
@@ -308,8 +321,15 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsNoFlags) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_99, false);
-  SetQuicReloadableFlag(quic_supports_tls_handshake, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_t050, false);
+  SetQuicReloadableFlag(quic_disable_version_q050, false);
+  SetQuicReloadableFlag(quic_disable_version_q049, false);
+  SetQuicReloadableFlag(quic_disable_version_q048, false);
+  SetQuicReloadableFlag(quic_disable_version_q046, false);
+  SetQuicReloadableFlag(quic_disable_version_q043, false);
+
   ParsedQuicVersionVector expected_parsed_versions;
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
@@ -401,17 +421,41 @@
 TEST_F(QuicVersionsTest, QuicEnableVersion) {
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+  ParsedQuicVersion parsed_version_q099 =
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99);
   ParsedQuicVersion parsed_version_t099 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  SetQuicReloadableFlag(quic_supports_tls_handshake, false);
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  ParsedQuicVersion parsed_version_q050 =
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50);
+  ParsedQuicVersion parsed_version_t050 =
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50);
 
   {
     QuicFlagSaver flag_saver;
+    SetQuicReloadableFlag(quic_enable_version_q099, false);
+    QuicEnableVersion(parsed_version_q099);
+    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_q099));
+  }
+
+  {
+    QuicFlagSaver flag_saver;
+    SetQuicReloadableFlag(quic_enable_version_t099, false);
     QuicEnableVersion(parsed_version_t099);
-    EXPECT_TRUE(GetQuicReloadableFlag(quic_supports_tls_handshake));
-    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_99));
+    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t099));
+  }
+
+  {
+    QuicFlagSaver flag_saver;
+    SetQuicReloadableFlag(quic_disable_version_q050, true);
+    QuicEnableVersion(parsed_version_q050);
+    EXPECT_FALSE(GetQuicReloadableFlag(quic_disable_version_q050));
+  }
+
+  {
+    QuicFlagSaver flag_saver;
+    SetQuicReloadableFlag(quic_enable_version_t050, false);
+    QuicEnableVersion(parsed_version_t050);
+    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t050));
   }
 }
 
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index 08b4eb9..bc09994 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -17,8 +17,6 @@
                              QuicSession* session,
                              SSL_CTX* /*ssl_ctx*/)
     : stream_(stream), session_(session), delegate_(session) {
-  QUIC_BUG_IF(!GetQuicReloadableFlag(quic_supports_tls_handshake))
-      << "Attempted to create TLS handshaker when TLS is disabled";
 }
 
 TlsHandshaker::~TlsHandshaker() {}
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index a86b521..75f07aa 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -309,7 +309,6 @@
             {ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99)})),
         client_session_(client_conn_, /*create_mock_crypto_stream=*/false),
         server_session_(server_conn_, /*create_mock_crypto_stream=*/false) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     client_stream_ = new TestQuicCryptoClientStream(&client_session_);
     client_session_.SetCryptoStream(client_stream_);
     server_stream_ =
diff --git a/quic/quartc/quartc_endpoint_test.cc b/quic/quartc/quartc_endpoint_test.cc
index 8506067..d2f9420 100644
--- a/quic/quartc/quartc_endpoint_test.cc
+++ b/quic/quartc/quartc_endpoint_test.cc
@@ -49,7 +49,11 @@
             simulator_.GetRandomGenerator(),
             &client_endpoint_delegate_,
             QuartcSessionConfig(),
-            /*serialized_server_config=*/"")) {}
+            /*serialized_server_config=*/"")) {
+    // Make sure these versions are enabled since some tests use them.
+    SetQuicReloadableFlag(quic_disable_version_q043, false);
+    SetQuicReloadableFlag(quic_disable_version_q046, false);
+  }
 
   simulator::Simulator simulator_;
 
diff --git a/quic/quartc/quartc_multiplexer_test.cc b/quic/quartc/quartc_multiplexer_test.cc
index 3cc088b..9b989be 100644
--- a/quic/quartc/quartc_multiplexer_test.cc
+++ b/quic/quartc/quartc_multiplexer_test.cc
@@ -199,8 +199,10 @@
             simulator_.GetRandomGenerator(),
             &server_multiplexer_,
             quic::QuartcSessionConfig())) {
+    quic::test::QuicEnableDefaultEnabledVersions();
     // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
-    SetQuicReloadableFlag(quic_enable_version_99, false);
+    SetQuicReloadableFlag(quic_enable_version_q099, false);
+    SetQuicReloadableFlag(quic_enable_version_t099, false);
   }
 
   void Connect() {
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index 956073b..195baa4 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -51,6 +51,11 @@
   ~QuartcSessionTest() override {}
 
   void Init(bool create_client_endpoint = true) {
+    quic::test::QuicEnableDefaultEnabledVersions();
+    // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
+    SetQuicReloadableFlag(quic_enable_version_q099, false);
+    SetQuicReloadableFlag(quic_enable_version_t099, false);
+
     client_transport_ =
         std::make_unique<simulator::SimulatedQuartcPacketTransport>(
             &simulator_, "client_transport", "server_transport",
@@ -336,7 +341,8 @@
 
 TEST_F(QuartcSessionTest, SendReceiveMessages) {
   // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
 
   CreateClientAndServerSessions(QuartcSessionConfig());
   AwaitHandshake();
@@ -345,7 +351,8 @@
 
 TEST_F(QuartcSessionTest, SendReceiveQueuedMessages) {
   // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
 
   CreateClientAndServerSessions(QuartcSessionConfig());
   AwaitHandshake();
@@ -406,7 +413,8 @@
 
 TEST_F(QuartcSessionTest, PreSharedKeyHandshake) {
   // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
 
   QuartcSessionConfig config;
   config.pre_shared_key = "foo";
@@ -552,7 +560,8 @@
 
 TEST_F(QuartcSessionTest, LostDatagramNotifications) {
   // TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
-  SetQuicReloadableFlag(quic_enable_version_99, false);
+  SetQuicReloadableFlag(quic_enable_version_q099, false);
+  SetQuicReloadableFlag(quic_enable_version_t099, false);
 
   // Disable tail loss probe, otherwise test maybe flaky because dropped
   // message will be retransmitted to detect tail loss.
diff --git a/quic/quic_transport/quic_transport_client_session_test.cc b/quic/quic_transport/quic_transport_client_session_test.cc
index 17a4757..51a0eb8 100644
--- a/quic/quic_transport/quic_transport_client_session_test.cc
+++ b/quic/quic_transport/quic_transport_client_session_test.cc
@@ -57,7 +57,6 @@
                     Perspective::IS_CLIENT,
                     GetVersions()),
         crypto_config_(crypto_test_utils::ProofVerifierForTesting()) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     CreateSession(GetTestOrigin(), "");
   }
 
diff --git a/quic/quic_transport/quic_transport_integration_test.cc b/quic/quic_transport/quic_transport_integration_test.cc
index b8d8eae..1695a19 100644
--- a/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quic/quic_transport/quic_transport_integration_test.cc
@@ -60,8 +60,6 @@
         simulator, simulator->GetAlarmFactory(), &writer_,
         /*owns_writer=*/false, perspective, GetVersions());
     connection_->SetSelfAddress(simulator::GetAddressFromName(name));
-
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   }
 };
 
diff --git a/quic/quic_transport/quic_transport_server_session_test.cc b/quic/quic_transport/quic_transport_server_session_test.cc
index efa668c..f99997a 100644
--- a/quic/quic_transport/quic_transport_server_session_test.cc
+++ b/quic/quic_transport/quic_transport_server_session_test.cc
@@ -67,7 +67,6 @@
                        KeyExchangeSource::Default()),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     connection_.AdvanceTime(QuicTime::Delta::FromSeconds(100000));
     crypto_test_utils::SetupCryptoServerConfigForTest(
         helper_.GetClock(), helper_.GetRandomGenerator(), &crypto_config_);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 4b10826..8099c34 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -828,6 +828,21 @@
   return AllSupportedTransportVersions().back();
 }
 
+void QuicEnableDefaultEnabledVersions() {
+  if (!GetQuicReloadableFlag(quic_testonly_default_false)) {
+    // If quic_testonly_default_false is false, then we are not in a mode where
+    // all flags have been flipped to true.
+    return;
+  }
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
+                "Supported versions out of sync");
+  SetQuicReloadableFlag(quic_disable_version_q050, false);
+  SetQuicReloadableFlag(quic_disable_version_q049, false);
+  SetQuicReloadableFlag(quic_disable_version_q048, false);
+  SetQuicReloadableFlag(quic_disable_version_q046, false);
+  SetQuicReloadableFlag(quic_disable_version_q043, false);
+}
+
 QuicEncryptedPacket* ConstructEncryptedPacket(
     QuicConnectionId destination_connection_id,
     QuicConnectionId source_connection_id,
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 7919ef3..d8fbc78 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -71,6 +71,9 @@
 // TODO(nharper): Remove this function when it is no longer used.
 QuicTransportVersion QuicTransportVersionMin();
 
+// Ensures that not all versions are disabled when all flags are set to true.
+void QuicEnableDefaultEnabledVersions();
+
 // Create an encrypted packet for testing.
 // If versions == nullptr, uses &AllSupportedVersions().
 // Note that the packet is encrypted with NullEncrypter, so to decrypt the
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index a548c6c..0af12e2 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -194,7 +194,6 @@
                        KeyExchangeSource::Default()),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
-    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     config_.SetMaxIncomingBidirectionalStreamsToSend(kMaxStreamsForTest);
     QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
         &config_, kMaxStreamsForTest);
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 4159735..30018c2 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -192,10 +192,6 @@
     quic::QuicEnableVersion(versions[0]);
 
   } else if (!quic_version_string.empty()) {
-    if (quic_version_string[0] == 'T') {
-      // ParseQuicVersionString checks quic_supports_tls_handshake.
-      SetQuicReloadableFlag(quic_supports_tls_handshake, true);
-    }
     quic::ParsedQuicVersion parsed_quic_version =
         quic::ParseQuicVersionString(quic_version_string);
     if (parsed_quic_version.transport_version ==