diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index e24c493..bb8bf60 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -59,7 +59,6 @@
 QUICHE_FLAG(bool, quiche_restart_flag_quic_support_release_time_for_gso, false, false, "If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_testonly_default_false, false, false, "A testonly restart flag that will always default to false.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_testonly_default_true, true, true, "A testonly restart flag that will always default to true.")
-QUICHE_FLAG(bool, quiche_restart_flag_quic_use_one_map_in_time_wait_list, true, true, "If true, use a single connection ID data map in time wait list manager.")
 
 #endif
 // clang-format on
diff --git a/quiche/quic/core/quic_time_wait_list_manager.cc b/quiche/quic/core/quic_time_wait_list_manager.cc
index 0699656..8d15548 100644
--- a/quiche/quic/core/quic_time_wait_list_manager.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager.cc
@@ -96,13 +96,6 @@
 QuicTimeWaitListManager::ConnectionIdData* /*absl_nullable*/
 QuicTimeWaitListManager::FindConnectionIdData(
     const QuicConnectionId& connection_id) {
-  if (use_old_connection_id_map_) {
-    auto it = FindConnectionIdDataInMap(connection_id);
-    if (it == connection_id_map_.end()) {
-      return nullptr;
-    }
-    return &it->second;
-  }
   auto it = connection_id_data_map_.find(connection_id);
   if (it == connection_id_data_map_.end()) {
     return nullptr;
@@ -110,39 +103,6 @@
   return it->second.get();
 }
 
-QuicTimeWaitListManager::ConnectionIdMap::iterator
-QuicTimeWaitListManager::FindConnectionIdDataInMap(
-    const QuicConnectionId& connection_id) {
-  QUICHE_DCHECK(use_old_connection_id_map_);
-  auto it = indirect_connection_id_map_.find(connection_id);
-  if (it == indirect_connection_id_map_.end()) {
-    return connection_id_map_.end();
-  }
-  return connection_id_map_.find(it->second);
-}
-
-void QuicTimeWaitListManager::AddConnectionIdDataToMap(
-    const QuicConnectionId& canonical_connection_id, int num_packets,
-    TimeWaitAction action, TimeWaitConnectionInfo info) {
-  QUICHE_DCHECK(use_old_connection_id_map_);
-  for (const auto& cid : info.active_connection_ids) {
-    indirect_connection_id_map_[cid] = canonical_connection_id;
-  }
-  ConnectionIdData data(num_packets, clock_->ApproximateNow(), action,
-                        std::move(info));
-  connection_id_map_.emplace(
-      std::make_pair(canonical_connection_id, std::move(data)));
-}
-
-void QuicTimeWaitListManager::RemoveConnectionDataFromMap(
-    ConnectionIdMap::iterator it) {
-  QUICHE_DCHECK(use_old_connection_id_map_);
-  for (const auto& cid : it->second.info.active_connection_ids) {
-    indirect_connection_id_map_.erase(cid);
-  }
-  connection_id_map_.erase(it);
-}
-
 void QuicTimeWaitListManager::AddConnectionIdToTimeWait(
     TimeWaitAction action, TimeWaitConnectionInfo info) {
   if (info.active_connection_ids.empty()) {
@@ -153,24 +113,6 @@
                 !info.termination_packets.empty());
   QUICHE_DCHECK(action != DO_NOTHING || info.ietf_quic);
 
-  if (use_old_connection_id_map_) {
-    const QuicConnectionId canonical_connection_id =
-        info.active_connection_ids.front();
-    int num_packets = 0;
-    auto it = FindConnectionIdDataInMap(canonical_connection_id);
-    const bool new_connection_id = it == connection_id_map_.end();
-    if (!new_connection_id) {  // Replace record if it is reinserted.
-      QUIC_CODE_COUNT(quic_time_wait_list_manager_reinsert_connection_id);
-      num_packets = it->second.num_packets;
-      RemoveConnectionDataFromMap(it);
-    }
-    TrimTimeWaitListIfNeeded();
-    AddConnectionIdDataToMap(canonical_connection_id, num_packets, action,
-                             std::move(info));
-    return;
-  }
-
-  QUIC_RESTART_FLAG_COUNT(quic_use_one_map_in_time_wait_list);
   TrimTimeWaitListIfNeeded();
 
   quiche::QuicheReferenceCountedPointer<RefCountedConnectionIdData> data(
@@ -191,9 +133,6 @@
 
 bool QuicTimeWaitListManager::IsConnectionIdInTimeWait(
     QuicConnectionId connection_id) const {
-  if (use_old_connection_id_map_) {
-    return indirect_connection_id_map_.contains(connection_id);
-  }
   return connection_id_data_map_.contains(connection_id);
 }
 
@@ -455,9 +394,6 @@
 
 QuicTime QuicTimeWaitListManager::GetOldestConnectionTime() const {
   QUICHE_DCHECK(has_connections());
-  if (use_old_connection_id_map_) {
-    return connection_id_map_.begin()->second.time_added;
-  }
   return connection_id_data_map_.begin()->second->time_added;
 }
 
@@ -486,16 +422,6 @@
   if (!has_connections()) {
     return false;
   }
-  if (use_old_connection_id_map_) {
-    auto it = connection_id_map_.begin();
-    QuicTime oldest_connection_id_time = it->second.time_added;
-    if (oldest_connection_id_time > expiration_time) {
-      // Too recent, don't retire.
-      return false;
-    }
-    RemoveConnectionDataFromMap(it);
-    return true;
-  }
   auto it = connection_id_data_map_.begin();
   QuicTime oldest_connection_id_time = it->second->time_added;
   if (oldest_connection_id_time > expiration_time) {
@@ -528,19 +454,16 @@
     return;
   }
   while (has_connections() &&
-         num_connections() >= static_cast<size_t>(kMaxConnections)) {
+         num_connections_ >= static_cast<size_t>(kMaxConnections)) {
     MaybeExpireOldestConnection(QuicTime::Infinite());
     QUIC_CODE_COUNT(quic_time_wait_list_trim_full);
   }
 
   QUICHE_DCHECK(!has_connections() ||
-                num_connections() < static_cast<size_t>(kMaxConnections));
+                num_connections_ < static_cast<size_t>(kMaxConnections));
 }
 
 bool QuicTimeWaitListManager::has_connections() const {
-  if (use_old_connection_id_map_) {
-    return !connection_id_map_.empty();
-  }
   QUIC_BUG_IF(quic_time_wait_list_num_connections_inconsistent,
               num_connections_ > connection_id_data_map_.size());
   return num_connections_ > 0;
diff --git a/quiche/quic/core/quic_time_wait_list_manager.h b/quiche/quic/core/quic_time_wait_list_manager.h
index b1e7204..706c3db 100644
--- a/quiche/quic/core/quic_time_wait_list_manager.h
+++ b/quiche/quic/core/quic_time_wait_list_manager.h
@@ -16,7 +16,6 @@
 #include <vector>
 
 #include "absl/base/nullability.h"
-#include "absl/container/flat_hash_map.h"
 #include "quiche/quic/core/quic_alarm.h"
 #include "quiche/quic/core/quic_alarm_factory.h"
 #include "quiche/quic/core/quic_blocked_writer_interface.h"
@@ -153,11 +152,7 @@
   // the size is under the configured maximum.
   void TrimTimeWaitListIfNeeded();
 
-  // The number of connections on the time-wait list.
-  size_t num_connections() const {
-    return use_old_connection_id_map_ ? connection_id_map_.size()
-                                      : num_connections_;
-  }
+  size_t num_connections() const { return num_connections_; }
   bool has_connections() const;
 
   // Sends a version negotiation packet for |server_connection_id| and
@@ -317,8 +312,6 @@
   // Returns the time when the first connection was added to the time-wait list.
   QuicTime GetOldestConnectionTime() const;
 
-  const bool use_old_connection_id_map_ =
-      !GetQuicRestartFlag(quic_use_one_map_in_time_wait_list);
   size_t num_connections_ = 0;
 
   // QuicheLinkedHashMap allows lookup by ConnectionId
@@ -329,35 +322,9 @@
       QuicConnectionIdHash>
       connection_id_data_map_;
 
-  using ConnectionIdMap =
-      quiche::QuicheLinkedHashMap<QuicConnectionId, ConnectionIdData,
-                                  QuicConnectionIdHash>;
-  // Do not use find/emplace/erase on this map directly. Use
-  // FindConnectionIdDataInMap, AddConnectionIdDateToMap,
-  // RemoveConnectionDataFromMap instead.
-  ConnectionIdMap connection_id_map_;
-
-  // A connection can have multiple unretired ConnectionIds when it is closed.
-  // These Ids have the same ConnectionIdData entry in connection_id_map_. To
-  // find the entry, look up the cannoical ConnectionId in
-  // indirect_connection_id_map_ first, and look up connection_id_map_ with the
-  // cannoical ConnectionId.
-  absl::flat_hash_map<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash>
-      indirect_connection_id_map_;
-
   // Find data for the given connection_id. Returns nullptr if not found.
   ConnectionIdData* /*absl_nullable*/ FindConnectionIdData(
       const QuicConnectionId& connection_id);
-  // Find an iterator for the given connection_id. Returns
-  // connection_id_map_.end() if none found.
-  ConnectionIdMap::iterator FindConnectionIdDataInMap(
-      const QuicConnectionId& connection_id);
-  // Inserts a ConnectionIdData entry to connection_id_map_.
-  void AddConnectionIdDataToMap(const QuicConnectionId& canonical_connection_id,
-                                int num_packets, TimeWaitAction action,
-                                TimeWaitConnectionInfo info);
-  // Removes a ConnectionIdData entry in connection_id_map_.
-  void RemoveConnectionDataFromMap(ConnectionIdMap::iterator it);
 
   // Pending termination packets that need to be sent out to the peer when we
   // are given a chance to write by the dispatcher.
diff --git a/quiche/quic/core/quic_time_wait_list_manager_test.cc b/quiche/quic/core/quic_time_wait_list_manager_test.cc
index 8257962..883d348 100644
--- a/quiche/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager_test.cc
@@ -539,17 +539,10 @@
       QuicTimeWaitListManager::SEND_STATELESS_RESET,
       TimeWaitConnectionInfo(false, nullptr, {cid1, cid3}));
 
-  if (GetQuicRestartFlag(quic_use_one_map_in_time_wait_list)) {
-    EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid1));
-    EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid2));
-    EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid3));
-    EXPECT_EQ(time_wait_list_manager_.num_connections(), 2u);
-  } else {
-    EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid1));
-    EXPECT_FALSE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid2));
-    EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid3));
-    EXPECT_EQ(time_wait_list_manager_.num_connections(), 1u);
-  }
+  EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid1));
+  EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid2));
+  EXPECT_TRUE(time_wait_list_manager_.IsConnectionIdInTimeWait(cid3));
+  EXPECT_EQ(time_wait_list_manager_.num_connections(), 2u);
 }
 
 TEST_F(QuicTimeWaitListManagerTest, ConnectionIdsOrderedByTime) {