diff --git a/routing/transit_graph.cpp b/routing/transit_graph.cpp
index ec7e28f0a8..a60b51c6ad 100644
--- a/routing/transit_graph.cpp
+++ b/routing/transit_graph.cpp
@@ -13,6 +13,14 @@ Segment GetReverseSegment(Segment const & segment)
   return Segment(segment.GetMwmId(), segment.GetFeatureId(), segment.GetSegmentIdx(),
                  !segment.IsForward());
 }
+
+Junction const & GetStopJunction(map<transit::StopId, Junction> const & stopCoords,
+                                 transit::StopId stopId)
+{
+  auto const it = stopCoords.find(stopId);
+  CHECK(it != stopCoords.cend(), ("Stop", stopId, "does not exist."));
+  return it->second;
+}
 }  // namespace
 
 // static
@@ -91,14 +99,14 @@ void TransitGraph::Fill(vector<transit::Stop> const & stops, vector<transit::Gat
       AddGate(gate, ending, stopCoords, false /* isEnter */);
   }
 
-  map<transit::StopId, set<transit::Edge>> outgoing;
-  map<transit::StopId, set<transit::Edge>> ingoing;
+  map<transit::StopId, set<Segment>> outgoing;
+  map<transit::StopId, set<Segment>> ingoing;
   for (auto const & edge : edges)
   {
     CHECK_NOT_EQUAL(edge.GetWeight(), transit::kInvalidWeight, ("Edge should have valid weight."));
-    AddEdge(edge, stopCoords);
-    outgoing[edge.GetStop1Id()].insert(edge);
-    ingoing[edge.GetStop2Id()].insert(edge);
+    auto const edgeSegment = AddEdge(edge, stopCoords);
+    outgoing[edge.GetStop1Id()].insert(edgeSegment);
+    ingoing[edge.GetStop2Id()].insert(edgeSegment);
   }
 
   AddConnections(outgoing, true /* isOutgoing */);
@@ -168,41 +176,36 @@ void TransitGraph::AddGate(transit::Gate const & gate, FakeEnding const & ending
   }
 }
 
-void TransitGraph::AddEdge(transit::Edge const & edge,
-                           map<transit::StopId, Junction> const & stopCoords)
+Segment TransitGraph::AddEdge(transit::Edge const & edge,
+                              map<transit::StopId, Junction> const & stopCoords)
 {
   auto const edgeSegment = GetNewTransitSegment();
-  auto const startStopId = edge.GetStop1Id();
-  auto const finishStopId = edge.GetStop2Id();
-  auto const startStopIt = stopCoords.find(startStopId);
-  CHECK(startStopIt != stopCoords.end(), ("Stop", startStopId, "does not exist."));
-  auto const finishStopIt = stopCoords.find(finishStopId);
-  CHECK(finishStopIt != stopCoords.end(), ("Stop", finishStopId, "does not exist."));
-  FakeVertex edgeVertex(startStopIt->second, finishStopIt->second, FakeVertex::Type::PureFake);
+  auto const stopFromId = edge.GetStop1Id();
+  auto const stopToId = edge.GetStop2Id();
+  FakeVertex edgeVertex(GetStopJunction(stopCoords, stopFromId),
+                        GetStopJunction(stopCoords, stopToId), FakeVertex::Type::PureFake);
   m_fake.AddStandaloneVertex(edgeSegment, edgeVertex);
   m_segmentToEdge[edgeSegment] = edge;
-  m_edgeToSegment[edge] = edgeSegment;
-  m_stopToBack[startStopId].insert(edgeSegment);
-  m_stopToFront[finishStopId].insert(edgeSegment);
+  m_stopToBack[stopFromId].insert(edgeSegment);
+  m_stopToFront[stopToId].insert(edgeSegment);
+  return edgeSegment;
 }
 
-void TransitGraph::AddConnections(map<transit::StopId, set<transit::Edge>> const & connections,
+void TransitGraph::AddConnections(map<transit::StopId, set<Segment>> const & connections,
                                   bool isOutgoing)
 {
   for (auto const & connection : connections)
   {
-    for (auto const & edge : connection.second)
+    for (auto const & connectedSegment : connection.second)
     {
-      auto const edgeIt = m_edgeToSegment.find(edge);
-      CHECK(edgeIt != m_edgeToSegment.cend(), ("Unknown edge", edge));
       auto const & adjacentSegments = isOutgoing ? m_stopToFront : m_stopToBack;
       auto const segmentsIt = adjacentSegments.find(connection.first);
       if (segmentsIt == adjacentSegments.cend())
         continue;
       for (auto const & segment : segmentsIt->second)
       {
-        m_fake.AddConnection(isOutgoing ? segment : edgeIt->second,
-                             isOutgoing ? edgeIt->second : segment);
+        m_fake.AddConnection(isOutgoing ? segment : connectedSegment,
+                             isOutgoing ? connectedSegment : segment);
       }
     }
   }
diff --git a/routing/transit_graph.hpp b/routing/transit_graph.hpp
index 4a6bc26149..d767cbf9af 100644
--- a/routing/transit_graph.hpp
+++ b/routing/transit_graph.hpp
@@ -45,8 +45,10 @@ private:
 
   void AddGate(transit::Gate const & gate, FakeEnding const & ending,
                std::map<transit::StopId, Junction> const & stopCoords, bool isEnter);
-  void AddEdge(transit::Edge const & edge, std::map<transit::StopId, Junction> const & stopCoords);
-  void AddConnections(map<transit::StopId, std::set<transit::Edge>> const & connections,
+  // Adds transit edge to fake graph, returns corresponding transit segment.
+  Segment AddEdge(transit::Edge const & edge,
+                  std::map<transit::StopId, Junction> const & stopCoords);
+  void AddConnections(std::map<transit::StopId, std::set<Segment>> const & connections,
                       bool isOutgoing);
 
   bool IsGate(Segment const & segment) const;
@@ -60,7 +62,6 @@ private:
   std::map<Segment, transit::Edge> m_segmentToEdge;
   std::map<Segment, transit::Gate> m_segmentToGate;
   // TODO (@t.yan) move m_edgeToSegment, m_stopToBack, m_stopToFront to Fill
-  std::map<transit::Edge, Segment> m_edgeToSegment;
   std::map<transit::StopId, std::set<Segment>> m_stopToBack;
   std::map<transit::StopId, std::set<Segment>> m_stopToFront;
 };
diff --git a/routing_common/transit_types.cpp b/routing_common/transit_types.cpp
index 99f7141c3e..4c316a81ec 100644
--- a/routing_common/transit_types.cpp
+++ b/routing_common/transit_types.cpp
@@ -133,25 +133,14 @@ Edge::Edge(StopId stop1Id, StopId stop2Id, double weight, LineId lineId, bool tr
 {
 }
 
-bool Edge::operator<(Edge const & rhs) const
+bool Edge::IsEqualForTesting(Edge const & edge) const
 {
-  if (m_stop1Id != rhs.m_stop1Id)
-    return m_stop1Id < rhs.m_stop1Id;
-  if (m_stop2Id != rhs.m_stop2Id)
-    return m_stop2Id < rhs.m_stop2Id;
-  if (m_lineId != rhs.m_lineId)
-    return m_lineId < rhs.m_lineId;
-  if (m_transfer != rhs.m_transfer)
-    return m_transfer < rhs.m_transfer;
-  if (m_shapeIds != rhs.m_shapeIds)
-    return m_shapeIds < rhs.m_shapeIds;
-  if (!my::AlmostEqualAbs(m_weight, rhs.m_weight, kWeightEqualEpsilon))
-    return m_weight < rhs.m_weight;
-  return false;
+  return m_stop1Id == edge.m_stop1Id && m_stop2Id == edge.m_stop2Id &&
+         my::AlmostEqualAbs(m_weight, edge.m_weight, kWeightEqualEpsilon) &&
+         m_lineId == edge.m_lineId && m_transfer == edge.m_transfer &&
+         m_shapeIds == edge.m_shapeIds;
 }
 
-bool Edge::IsEqualForTesting(Edge const & edge) const { return !(*this < edge || edge < *this); }
-
 // Transfer ---------------------------------------------------------------------------------------
 Transfer::Transfer(StopId id, m2::PointD const & point, std::vector<StopId> const & stopIds,
                    std::vector<TitleAnchor> const & titleAnchors)
diff --git a/routing_common/transit_types.hpp b/routing_common/transit_types.hpp
index 58aa7ed8f5..f8d5011a5f 100644
--- a/routing_common/transit_types.hpp
+++ b/routing_common/transit_types.hpp
@@ -199,8 +199,6 @@ public:
   bool GetTransfer() const { return m_transfer; }
   std::vector<ShapeId> const & GetShapeIds() const { return m_shapeIds; }
 
-  bool operator<(Edge const & rhs) const;
-
 private:
   DECLARE_TRANSIT_TYPE_FRIENDS
   DECLARE_VISITOR_AND_DEBUG_PRINT(Edge, visitor(m_stop1Id, "stop1_id"),