diff --git a/routing/routing_tests/turns_sound_test.cpp b/routing/routing_tests/turns_sound_test.cpp
index 3ad98fb75c..633a38922f 100644
--- a/routing/routing_tests/turns_sound_test.cpp
+++ b/routing/routing_tests/turns_sound_test.cpp
@@ -325,6 +325,75 @@ UNIT_TEST(TurnsSoundFeetTest)
 
   TEST(turnSound.IsEnabled(), ());
 }
+
+UNIT_TEST(TurnsSoundComposedTurnTest)
+{
+  TurnsSound turnSound;
+  turnSound.Enable(true);
+  turnSound.SetLengthUnits(routing::turns::sound::LengthUnits::Meters);
+  string const engShortJson =
+      "\
+      {\
+      \"in_600_meters\":\"In 600 meters.\",\
+      \"make_a_right_turn\":\"Turn right.\",\
+      \"enter_the_roundabout\":\"Enter the roundabout.\",\
+      \"then\":\"Then.\",\
+      \"you_have_reached_the_destination\":\"You have reached the destination.\"\
+      }";
+  turnSound.m_getTtsText.ForTestingSetLocaleWithJson(engShortJson);
+  turnSound.m_settings.ForTestingSetNotificationTimeSecond(30);
+
+  turnSound.Reset();
+  turnSound.SetSpeedMetersPerSecond(20.);
+  vector<string> turnNotifications;
+
+  // Starting nearing the first turn.
+  // 800 meters till the first turn.
+  vector<TurnItemDist> const turns1 = {{{5 /* idx */, TurnDirection::TurnRight}, 800. /* m_distMeters */},
+                                       {{10 /* idx */, TurnDirection::EnterRoundAbout}, 1000. /* m_distMeters */}};
+  turnSound.GenerateTurnSound(turns1, turnNotifications);
+  TEST(turnNotifications.empty(), ());
+
+  // 620 meters till the first turn.
+  turnNotifications.clear();
+  vector<TurnItemDist> const turns2 = {{{5 /* idx */, TurnDirection::TurnRight}, 620. /* m_distMeters */},
+                                       {{10 /* idx */, TurnDirection::EnterRoundAbout}, 820. /* m_distMeters */}};
+  vector<string> const expectedNotification2 = {{"In 600 meters. Turn right."},
+                                                {"Then. Enter the roundabout."}};
+  turnSound.GenerateTurnSound(turns2, turnNotifications);
+  TEST_EQUAL(turnNotifications, expectedNotification2, ());
+
+  // 300 meters till the first turn.
+  turnNotifications.clear();
+  vector<TurnItemDist> const turns3 = {{{5 /* idx */, TurnDirection::TurnRight}, 300. /* m_distMeters */},
+                                       {{10 /* idx */, TurnDirection::EnterRoundAbout}, 500. /* m_distMeters */}};
+  turnSound.GenerateTurnSound(turns3, turnNotifications);
+  TEST(turnNotifications.empty(), ());
+
+  // 20 meters till the first turn.
+  turnNotifications.clear();
+  vector<TurnItemDist> const turns4 = {{{5 /* idx */, TurnDirection::TurnRight}, 20. /* m_distMeters */},
+                                       {{10 /* idx */, TurnDirection::EnterRoundAbout}, 220. /* m_distMeters */}};
+  vector<string> const expectedNotification4 = {{"Turn right."},
+                                                {"Then. Enter the roundabout."}};
+  turnSound.GenerateTurnSound(turns4, turnNotifications);
+  TEST_EQUAL(turnNotifications, expectedNotification4, ());
+
+  // After the first turn.
+  turnNotifications.clear();
+  vector<TurnItemDist> const turns5 = {{{10 /* idx */, TurnDirection::EnterRoundAbout}, 180. /* m_distMeters */},
+                                       {{15 /* idx */, TurnDirection::ReachedYourDestination}, 1180. /* m_distMeters */}};
+  turnSound.GenerateTurnSound(turns5, turnNotifications);
+  TEST(turnNotifications.empty(), ());
+
+  // Just before the second turn.
+  turnNotifications.clear();
+  vector<TurnItemDist> const turns6 = {{{10 /* idx */, TurnDirection::EnterRoundAbout}, 10. /* m_distMeters */},
+                                       {{15 /* idx */, TurnDirection::ReachedYourDestination}, 1010. /* m_distMeters */}};
+  vector<string> const expectedNotification6 = {{"Enter the roundabout."}};
+  turnSound.GenerateTurnSound(turns6, turnNotifications);
+  TEST_EQUAL(turnNotifications, expectedNotification6, ());
+}
 }  // namespace sound
 }  // namespace turns
 }  // namespace routing
diff --git a/routing/turns_sound.cpp b/routing/turns_sound.cpp
index ff7c521190..cbad6b4d69 100644
--- a/routing/turns_sound.cpp
+++ b/routing/turns_sound.cpp
@@ -73,6 +73,10 @@ void TurnsSound::GenerateTurnSound(vector<TurnItemDist> const & turns, vector<st
   if (secondNotification.empty())
     return;
   turnNotifications.emplace_back(move(secondNotification));
+  // Turn notification with word "Then" (about the second turn) will be pronounced.
+  // When this second turn become the first one the first notification about the turn
+  // shall be skipped.
+  m_turnNotificationWithThen = true;
 }
 
 string TurnsSound::GenerateFirstTurnSound(TurnItem const & turn, double distanceToTurnMeters)
@@ -98,12 +102,19 @@ string TurnsSound::GenerateFirstTurnSound(TurnItem const & turn, double distance
 
       if (distanceToTurnMeters < startPronounceDistMeters)
       {
-        // First turn sound notification.
-        uint32_t const distToPronounce =
-            m_settings.RoundByPresetSoundedDistancesUnits(turnNotificationDistUnits);
-        m_nextTurnNotificationProgress = PronouncedNotification::First;
-        return GenerateTurnText(distToPronounce, turn.m_exitNum, false /* useThenInsteadOfDistance */,
-                                turn.m_turn, m_settings.GetLengthUnits());
+        if (m_turnNotificationWithThen)
+        {
+          FastForwardFirstTurnNotification();
+        }
+        else
+        {
+          // Pronouncing first turn sound notification.
+          uint32_t const distToPronounce =
+              m_settings.RoundByPresetSoundedDistancesUnits(turnNotificationDistUnits);
+          m_nextTurnNotificationProgress = PronouncedNotification::First;
+          return GenerateTurnText(distToPronounce, turn.m_exitNum, false /* useThenInsteadOfDistance */,
+                                  turn.m_turn, m_settings.GetLengthUnits());
+        }
       }
     }
     else
@@ -111,6 +122,7 @@ string TurnsSound::GenerateFirstTurnSound(TurnItem const & turn, double distance
       // The first notification has not been pronounced but the distance to the turn is too short.
       // It happens if one turn follows shortly behind another one.
       m_nextTurnNotificationProgress = PronouncedNotification::First;
+      FastForwardFirstTurnNotification();
     }
     return string();
   }
@@ -119,6 +131,7 @@ string TurnsSound::GenerateFirstTurnSound(TurnItem const & turn, double distance
       distanceToTurnMeters < distanceToPronounceNotificationMeters)
   {
     m_nextTurnNotificationProgress = PronouncedNotification::Second;
+    FastForwardFirstTurnNotification();
     return GenerateTurnText(0 /* distanceUnits */, turn.m_exitNum,
                             false /* useThenInsteadOfDistance */,
                             turn.m_turn, m_settings.GetLengthUnits());
@@ -168,6 +181,14 @@ void TurnsSound::Reset()
 {
   m_nextTurnNotificationProgress = PronouncedNotification::Nothing;
   m_nextTurnIndex = 0;
+  m_turnNotificationWithThen = false;
+}
+
+void TurnsSound::FastForwardFirstTurnNotification()
+{
+  m_turnNotificationWithThen = false;
+  if (m_nextTurnNotificationProgress == PronouncedNotification::Nothing)
+    m_nextTurnNotificationProgress = PronouncedNotification::First;
 }
 
 string DebugPrint(PronouncedNotification const notificationProgress)
diff --git a/routing/turns_sound.hpp b/routing/turns_sound.hpp
index 94ccec8b6d..9266f6670c 100644
--- a/routing/turns_sound.hpp
+++ b/routing/turns_sound.hpp
@@ -36,6 +36,7 @@ class TurnsSound
   friend void UnitTest_TurnsSoundMetersTest();
   friend void UnitTest_TurnsSoundMetersTwoTurnsTest();
   friend void UnitTest_TurnsSoundFeetTest();
+  friend void UnitTest_TurnsSoundComposedTurnTest();
 
   /// m_enabled == true when tts is turned on.
   /// Important! Clients (iOS/Android) implies that m_enabled is false by default.
@@ -56,6 +57,11 @@ class TurnsSound
   /// After the second notification has been pronounced
   /// m_nextTurnNotificationProgress == Second.
   PronouncedNotification m_nextTurnNotificationProgress;
+  /// The flag is set to true if notification about the second turn was pronounced.
+  /// It could happen in expressions like "Turn right. Then turn left."
+  /// This flag is used to pass the information if second turn notification was pronounced
+  /// between two calls of GenerateTurnSound() method.
+  bool m_turnNotificationWithThen;
   uint32_t m_nextTurnIndex;
   /// getTtsText is a convector form turn notification information and locale to
   /// notification string.
@@ -65,9 +71,14 @@ class TurnsSound
                           TurnDirection turnDir, LengthUnits lengthUnits) const;
   /// Generates turn sound notification for the nearest to the current position turn.
   string GenerateFirstTurnSound(TurnItem const & turn, double distanceToTurnMeters);
+  /// Changes the state of the class to emulate that first turn notification is pronouned
+  /// without pronunciation.
+  void FastForwardFirstTurnNotification();
+
 public:
   TurnsSound() : m_enabled(false), m_speedMetersPerSecond(0.), m_settings(),
-      m_nextTurnNotificationProgress(PronouncedNotification::Nothing), m_nextTurnIndex(0) {}
+      m_nextTurnNotificationProgress(PronouncedNotification::Nothing),
+      m_turnNotificationWithThen(false),  m_nextTurnIndex(0) {}
 
   bool IsEnabled() const { return m_enabled; }
   void Enable(bool enable);