diff --git a/ksp_plugin/interface.cpp b/ksp_plugin/interface.cpp
index e57b948a27..a2f1181548 100644
--- a/ksp_plugin/interface.cpp
+++ b/ksp_plugin/interface.cpp
@@ -792,14 +792,6 @@ void principia__SetPartApparentDegreesOfFreedom(Plugin* const plugin,
   return m.Return();
 }
 
-void principia__SetPredictionLength(Plugin* const plugin,
-                                    double const t) {
-  journal::Method<journal::SetPredictionLength> m({plugin, t});
-  CHECK_NOTNULL(plugin);
-  plugin->SetPredictionLength(t * Second);
-  return m.Return();
-}
-
 // Make it so that all log messages of at least |min_severity| are logged to
 // stderr (in addition to logging to the usual log file(s)).
 void principia__SetStderrLogging(int const min_severity) {
diff --git a/ksp_plugin/interface_vessel.cpp b/ksp_plugin/interface_vessel.cpp
index 1ae9b40763..acb42c18bf 100644
--- a/ksp_plugin/interface_vessel.cpp
+++ b/ksp_plugin/interface_vessel.cpp
@@ -70,9 +70,9 @@ void principia__VesselSetPredictionAdaptiveStepParameters(
   journal::Method<journal::VesselSetPredictionAdaptiveStepParameters> m(
       {plugin, vessel_guid, adaptive_step_parameters});
   CHECK_NOTNULL(plugin);
-  plugin->GetVessel(vessel_guid)
-      ->set_prediction_adaptive_step_parameters(
-          FromAdaptiveStepParameters(adaptive_step_parameters));
+  plugin->SetPredictionAdaptiveStepParameters(
+      vessel_guid,
+      FromAdaptiveStepParameters(adaptive_step_parameters));
   return m.Return();
 }
 
diff --git a/ksp_plugin/plugin.cpp b/ksp_plugin/plugin.cpp
index f07be8980b..f3722ac340 100644
--- a/ksp_plugin/plugin.cpp
+++ b/ksp_plugin/plugin.cpp
@@ -51,6 +51,7 @@ namespace principia {
 namespace ksp_plugin {
 namespace internal_plugin {
 
+using astronomy::InfiniteFuture;
 using astronomy::ParseTT;
 using astronomy::KSPStockSystemFingerprint;
 using astronomy::KSPStabilizedSystemFingerprint;
@@ -680,10 +681,25 @@ RelativeDegreesOfFreedom<AliceSun> Plugin::CelestialFromParent(
   return result;
 }
 
+void Plugin::SetPredictionAdaptiveStepParameters(
+    GUID const& vessel_guid,
+    Ephemeris<Barycentric>::AdaptiveStepParameters const&
+        prediction_adaptive_step_parameters) const {
+  // If there is a target vessel, it is integrated with the same parameters as
+  // the given (current) vessel.  This makes it possible to plot the prediction
+  // of the current vessel.
+  if (renderer_->HasTargetVessel()) {
+    renderer_->GetTargetVessel().set_prediction_adaptive_step_parameters(
+        prediction_adaptive_step_parameters);
+  }
+  FindOrDie(vessels_, vessel_guid)
+      ->set_prediction_adaptive_step_parameters(
+          prediction_adaptive_step_parameters);
+}
+
 void Plugin::UpdatePrediction(GUID const& vessel_guid) const {
   CHECK(!initializing_);
-  FindOrDie(vessels_, vessel_guid)->UpdatePrediction(
-      current_time_ + prediction_length_);
+  FindOrDie(vessels_, vessel_guid)->UpdatePrediction(InfiniteFuture);
 }
 
 void Plugin::CreateFlightPlan(GUID const& vessel_guid,
@@ -730,11 +746,10 @@ void Plugin::ComputeAndRenderClosestApproaches(
     Position<World> const& sun_world_position,
     std::unique_ptr<DiscreteTrajectory<World>>& closest_approaches) const {
   CHECK(renderer_->HasTargetVessel());
-  UpdatePredictionForRendering(begin.trajectory()->Size());
 
   DiscreteTrajectory<Barycentric> apoapsides_trajectory;
   DiscreteTrajectory<Barycentric> periapsides_trajectory;
-  ComputeApsides(renderer_->GetTargetVessel().prediction(),
+  ComputeApsides(renderer_->GetTargetVesselPrediction(current_time_),
                  begin,
                  end,
                  apoapsides_trajectory,
@@ -754,10 +769,6 @@ void Plugin::ComputeAndRenderNodes(
     Position<World> const& sun_world_position,
     std::unique_ptr<DiscreteTrajectory<World>>& ascending,
     std::unique_ptr<DiscreteTrajectory<World>>& descending) const {
-  if (renderer_->HasTargetVessel()) {
-    UpdatePredictionForRendering(begin.trajectory()->Size());
-  }
-
   auto const trajectory_in_plotting =
       renderer_->RenderBarycentricTrajectoryInPlotting(begin, end);
   DiscreteTrajectory<Navigation> ascending_trajectory;
@@ -782,10 +793,6 @@ void Plugin::ComputeAndRenderNodes(
                    PlanetariumRotation());
 }
 
-void Plugin::SetPredictionLength(Time const& t) {
-  prediction_length_ = t;
-}
-
 void Plugin::SetPredictionAdaptiveStepParameters(
     Ephemeris<Barycentric>::AdaptiveStepParameters const&
         prediction_adaptive_step_parameters) {
@@ -873,11 +880,6 @@ void Plugin::SetTargetVessel(GUID const& vessel_guid,
   not_null<Celestial const*> const celestial =
       FindOrDie(celestials_, reference_body_index).get();
   not_null<Vessel*> const vessel = FindOrDie(vessels_, vessel_guid).get();
-  // Make sure that the current time is covered by the prediction.
-  if (current_time_ > vessel->prediction().t_max()) {
-    vessel->UpdatePrediction(current_time_ + prediction_length_);
-  }
-
   renderer_->SetTargetVessel(vessel, celestial, ephemeris_.get());
 }
 
@@ -1255,15 +1257,6 @@ void Plugin::UpdatePlanetariumRotation() {
       to_planetarium;
 }
 
-void Plugin::UpdatePredictionForRendering(std::int64_t const size) const {
-  auto& vessel = renderer_->GetTargetVessel();
-  auto parameters = vessel.prediction_adaptive_step_parameters();
-  // Adding one to ensure that we set a strictly positive max_steps.
-  parameters.set_max_steps(size + 1);
-  vessel.set_prediction_adaptive_step_parameters(parameters);
-  vessel.UpdatePrediction(current_time_ + prediction_length_);
-}
-
 Velocity<World> Plugin::VesselVelocity(
     Instant const& time,
     DegreesOfFreedom<Barycentric> const& degrees_of_freedom) const {
diff --git a/ksp_plugin/plugin.hpp b/ksp_plugin/plugin.hpp
index 7e7ec8631e..417f160dc3 100644
--- a/ksp_plugin/plugin.hpp
+++ b/ksp_plugin/plugin.hpp
@@ -278,6 +278,11 @@ class Plugin {
   virtual RelativeDegreesOfFreedom<AliceSun> CelestialFromParent(
       Index celestial_index) const;
 
+  virtual void SetPredictionAdaptiveStepParameters(
+      GUID const& vessel_guid,
+      Ephemeris<Barycentric>::AdaptiveStepParameters const&
+          prediction_adaptive_step_parameters) const;
+
   // Updates the prediction for the vessel with guid |vessel_guid|.
   void UpdatePrediction(GUID const& vessel_guid) const;
 
@@ -312,8 +317,6 @@ class Plugin {
       std::unique_ptr<DiscreteTrajectory<World>>& ascending,
       std::unique_ptr<DiscreteTrajectory<World>>& descending) const;
 
-  virtual void SetPredictionLength(Time const& t);
-
   virtual void SetPredictionAdaptiveStepParameters(
       Ephemeris<Barycentric>::AdaptiveStepParameters const&
           prediction_adaptive_step_parameters);
@@ -406,10 +409,6 @@ class Plugin {
   // whenever |main_body_| or |planetarium_rotation_| changes.
   void UpdatePlanetariumRotation();
 
-  // NOTE(egg): this is an ugly hack to try to get a long enough trajectory
-  // while retaining a timeout.
-  void UpdatePredictionForRendering(std::int64_t size) const;
-
   Velocity<World> VesselVelocity(
       Instant const& time,
       DegreesOfFreedom<Barycentric> const& degrees_of_freedom) const;
@@ -455,7 +454,6 @@ class Plugin {
   Ephemeris<Barycentric>::FixedStepParameters history_parameters_;
   Ephemeris<Barycentric>::AdaptiveStepParameters prolongation_parameters_;
   Ephemeris<Barycentric>::AdaptiveStepParameters prediction_parameters_;
-  Time prediction_length_ = 1 * Hour;
 
   // The thread pool for advancing vessels.
   ThreadPool<void> vessel_thread_pool_;
diff --git a/ksp_plugin/renderer.cpp b/ksp_plugin/renderer.cpp
index 9b9ac39b1c..db04016e26 100644
--- a/ksp_plugin/renderer.cpp
+++ b/ksp_plugin/renderer.cpp
@@ -1,6 +1,8 @@
 
 #include "ksp_plugin/renderer.hpp"
 
+#include <algorithm>
+
 #include "geometry/grassmann.hpp"
 #include "geometry/named_quantities.hpp"
 #include "physics/apsides.hpp"
@@ -40,7 +42,6 @@ void Renderer::SetTargetVessel(
     not_null<Vessel*> const vessel,
     not_null<Celestial const*> const celestial,
     not_null<Ephemeris<Barycentric> const*> const ephemeris) {
-  CHECK(!vessel->prediction().Empty());
   if (!target_ ||
       target_->vessel != vessel ||
       target_->celestial != celestial) {
@@ -72,6 +73,16 @@ Vessel const& Renderer::GetTargetVessel() const {
   return *target_->vessel;
 }
 
+DiscreteTrajectory<Barycentric> const& Renderer::GetTargetVesselPrediction(
+    Instant const& time) const {
+  CHECK(target_);
+  target_->vessel->UpdatePrediction(time);
+  // The prediction may not have been prolonged to |time| if we are near a
+  // singularity.
+  CHECK_LE(time, target_->vessel->prediction().last().time());
+  return target_->vessel->prediction();
+}
+
 not_null<std::unique_ptr<DiscreteTrajectory<World>>>
 Renderer::RenderBarycentricTrajectoryInWorld(
     Instant const& time,
@@ -94,20 +105,22 @@ not_null<std::unique_ptr<DiscreteTrajectory<Navigation>>>
 Renderer::RenderBarycentricTrajectoryInPlotting(
     DiscreteTrajectory<Barycentric>::Iterator const& begin,
     DiscreteTrajectory<Barycentric>::Iterator const& end) const {
-  CHECK(!target_ || !target_->vessel->prediction().Empty());
-
   auto trajectory = make_not_null_unique<DiscreteTrajectory<Navigation>>();
+  if (target_ && begin != end) {
+    auto last = end;
+    --last;
+    target_->vessel->UpdatePrediction(last.time());
+  }
   for (auto it = begin; it != end; ++it) {
+    Instant const& t = it.time();
     if (target_) {
-      if (it.time() < target_->vessel->prediction().t_min()) {
+      if (t < target_->vessel->prediction().t_min()) {
         continue;
-      } else if (it.time() > target_->vessel->prediction().t_max()) {
+      } else if (t > target_->vessel->prediction().t_max()) {
         break;
       }
     }
-    trajectory->Append(
-        it.time(),
-        BarycentricToPlotting(it.time())(it.degrees_of_freedom()));
+    trajectory->Append(t, BarycentricToPlotting(t)(it.degrees_of_freedom()));
   }
   return trajectory;
 }
@@ -158,7 +171,7 @@ Renderer::RenderPlottingTrajectoryInWorld(
 
 RigidMotion<Barycentric, Navigation> Renderer::BarycentricToPlotting(
     Instant const& time) const {
-  return GetPlottingFrame()->ToThisFrameAtTime(time);
+  return GetPlottingFrame(time)->ToThisFrameAtTime(time);
 }
 
 RigidTransformation<Barycentric, World> Renderer::BarycentricToWorld(
@@ -187,7 +200,6 @@ OrthogonalMap<Frenet<Navigation>, World> Renderer::FrenetToWorld(
     NavigationManœuvre const& manœuvre,
     Rotation<Barycentric, AliceSun> const& planetarium_rotation) const {
   Instant const initial_time = manœuvre.initial_time();
-  NavigationFrame const& plotting_frame = *GetPlottingFrame();
   return PlottingToWorld(time, planetarium_rotation) *
          BarycentricToPlotting(initial_time).orthogonal_map() *
          manœuvre.FrenetFrame();
@@ -204,8 +216,9 @@ OrthogonalMap<Frenet<Navigation>, World> Renderer::FrenetToWorld(
       BarycentricToPlotting(time)(barycentric_degrees_of_freedom);
   Rotation<Frenet<Navigation>, Navigation> const
       frenet_frame_to_plotting_frame =
-          GetPlottingFrame()->FrenetFrame(time,
-                                          plotting_frame_degrees_of_freedom);
+          GetPlottingFrame(time)->FrenetFrame(
+              time,
+              plotting_frame_degrees_of_freedom);
 
   return PlottingToWorld(time, planetarium_rotation) *
          frenet_frame_to_plotting_frame.Forget();
@@ -230,7 +243,7 @@ OrthogonalMap<Frenet<Navigation>, World> Renderer::FrenetToWorld(
 
 OrthogonalMap<Navigation, Barycentric> Renderer::PlottingToBarycentric(
     Instant const& time) const {
-  return GetPlottingFrame()->FromThisFrameAtTime(time).orthogonal_map();
+  return GetPlottingFrame(time)->FromThisFrameAtTime(time).orthogonal_map();
 }
 
 RigidTransformation<Navigation, World> Renderer::PlottingToWorld(
@@ -238,7 +251,8 @@ RigidTransformation<Navigation, World> Renderer::PlottingToWorld(
     Position<World> const& sun_world_position,
     Rotation<Barycentric, AliceSun> const& planetarium_rotation) const {
   return BarycentricToWorld(time, sun_world_position, planetarium_rotation) *
-         GetPlottingFrame()->FromThisFrameAtTime(time).rigid_transformation();
+         GetPlottingFrame(time)->
+             FromThisFrameAtTime(time).rigid_transformation();
 }
 
 OrthogonalMap<Navigation, World> Renderer::PlottingToWorld(
@@ -293,9 +307,17 @@ Renderer::Target::Target(
       target_frame(
           make_not_null_unique<
               BodyCentredBodyDirectionDynamicFrame<Barycentric, Navigation>>(
-                  ephemeris,
-                  [this]() -> auto& { return this->vessel->prediction(); },
-                  celestial->body())) {}
+              ephemeris,
+              [this]() -> auto& { return this->vessel->prediction(); },
+              celestial->body())) {}
+
+not_null<NavigationFrame const*> Renderer::GetPlottingFrame(
+    Instant const& time) const {
+  if (target_) {
+    GetTargetVesselPrediction(time);
+  }
+  return GetPlottingFrame();
+}
 
 }  // namespace internal_renderer
 }  // namespace ksp_plugin
diff --git a/ksp_plugin/renderer.hpp b/ksp_plugin/renderer.hpp
index 85ec815f84..f36367e909 100644
--- a/ksp_plugin/renderer.hpp
+++ b/ksp_plugin/renderer.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <experimental/optional>
+#include <functional>
 #include <memory>
 
 #include "base/not_null.hpp"
@@ -48,8 +49,7 @@ class Renderer {
   virtual not_null<NavigationFrame const*> GetPlottingFrame() const;
 
   // Overrides the current plotting frame with one that is centred on the given
-  // |vessel|.  When using the operations below with a target vessel, the client
-  // must ensure that the |time| is covered by the vessel's prediction.
+  // |vessel|.
   virtual void SetTargetVessel(
       not_null<Vessel*> vessel,
       not_null<Celestial const*> celestial,
@@ -65,6 +65,11 @@ class Renderer {
   virtual Vessel& GetTargetVessel();
   virtual Vessel const& GetTargetVessel() const;
 
+  // If there is a target vessel, returns its prediction after extending it up
+  // to |time|.
+  virtual DiscreteTrajectory<Barycentric> const& GetTargetVesselPrediction(
+      Instant const& time) const;
+
   // Returns a trajectory in |World| corresponding to the trajectory defined by
   // |begin| and |end|, as seen in the current plotting frame.  In this function
   // and others in this class, |sun_world_position| is the current position of
@@ -165,10 +170,6 @@ class Renderer {
       not_null<Ephemeris<Barycentric> const*> ephemeris);
 
  private:
-  not_null<Celestial const*> const sun_;
-
-  not_null<std::unique_ptr<NavigationFrame>> plotting_frame_;
-
   struct Target {
     Target(not_null<Vessel*> vessel,
            not_null<Celestial const*> celestial,
@@ -177,6 +178,15 @@ class Renderer {
     not_null<Celestial const*> const celestial;
     not_null<std::unique_ptr<NavigationFrame>> const target_frame;
   };
+
+  // Returns a plotting frame suitable for evaluation at |time|, possibly by
+  // extending the prediction if there is a target vessel.
+  not_null<NavigationFrame const*> GetPlottingFrame(Instant const& time) const;
+
+  not_null<Celestial const*> const sun_;
+
+  not_null<std::unique_ptr<NavigationFrame>> plotting_frame_;
+
   std::experimental::optional<Target> target_;
 };
 
diff --git a/ksp_plugin/vessel.cpp b/ksp_plugin/vessel.cpp
index 73e60bc470..79bb1858e8 100644
--- a/ksp_plugin/vessel.cpp
+++ b/ksp_plugin/vessel.cpp
@@ -229,9 +229,17 @@ void Vessel::DeleteFlightPlan() {
 }
 
 void Vessel::UpdatePrediction(Instant const& last_time) {
-  prediction_ = make_not_null_unique<DiscreteTrajectory<Barycentric>>();
-  auto const last = psychohistory_->last();
-  prediction_->Append(last.time(), last.degrees_of_freedom());
+  // TODO(phl): The prediction should probably be a fork of the psychohistory.
+  auto const psychohistory_last = psychohistory_->last();
+  auto const prediction_begin = prediction_->Begin();
+  if (prediction_->Empty() ||
+      prediction_begin.time() != psychohistory_last.time() ||
+      prediction_begin.degrees_of_freedom() !=
+          psychohistory_last.degrees_of_freedom()) {
+    prediction_ = make_not_null_unique<DiscreteTrajectory<Barycentric>>();
+    prediction_->Append(psychohistory_last.time(),
+                        psychohistory_last.degrees_of_freedom());
+  }
   FlowPrediction(last_time);
 }
 
diff --git a/ksp_plugin_adapter/ksp_plugin_adapter.cs b/ksp_plugin_adapter/ksp_plugin_adapter.cs
index 810009ac75..1da7f9b3dd 100644
--- a/ksp_plugin_adapter/ksp_plugin_adapter.cs
+++ b/ksp_plugin_adapter/ksp_plugin_adapter.cs
@@ -936,7 +936,6 @@ private void FixedUpdate() {
                       prediction_length_tolerance_index_]};
         plugin_.VesselSetPredictionAdaptiveStepParameters(
             main_vessel.id.ToString(), adaptive_step_parameters);
-        plugin_.SetPredictionLength(double.PositiveInfinity);
         plugin_.UpdatePrediction(main_vessel.id.ToString());
         string target_id =
             FlightGlobals.fetch.VesselTarget?.GetVessel()?.id.ToString();
@@ -952,7 +951,7 @@ private void FixedUpdate() {
       // TODO(egg): Set the degrees of freedom of the origin of |World| (by
       // toying with Krakensbane and FloatingOrigin) here.
 
-      // Now we let the game and Unity do their thing. among other things,
+      // Now we let the game and Unity do their thing.  Among other things,
       // the FashionablyLate callbacks, including ReportNonConservativeForces,
       // then the FlightIntegrator's FixedUpdate will run, then the Vessel's,
       // and eventually the physics simulation.
diff --git a/ksp_plugin_test/interface_test.cpp b/ksp_plugin_test/interface_test.cpp
index d527fd63e4..3180f409af 100644
--- a/ksp_plugin_test/interface_test.cpp
+++ b/ksp_plugin_test/interface_test.cpp
@@ -485,11 +485,6 @@ TEST_F(InterfaceTest, NewNavigationFrame) {
   EXPECT_EQ(mock_navigation_frame, navigation_frame.get());
 }
 
-TEST_F(InterfaceTest, PredictionGettersAndSetters) {
-  EXPECT_CALL(*plugin_, SetPredictionLength(42 * Second));
-  principia__SetPredictionLength(plugin_.get(), 42);
-}
-
 TEST_F(InterfaceTest, NavballOrientation) {
   StrictMock<MockDynamicFrame<Barycentric, Navigation>>* const
      mock_navigation_frame =
diff --git a/ksp_plugin_test/mock_plugin.hpp b/ksp_plugin_test/mock_plugin.hpp
index 80540b1124..bd4f404f15 100644
--- a/ksp_plugin_test/mock_plugin.hpp
+++ b/ksp_plugin_test/mock_plugin.hpp
@@ -68,8 +68,6 @@ class MockPlugin : public Plugin {
                           Instant const& final_time,
                           Mass const& initial_mass));
 
-  MOCK_METHOD1(SetPredictionLength, void(Time const& t));
-
   MOCK_METHOD1(SetPredictionAdaptiveStepParameters,
                void(Ephemeris<Barycentric>::AdaptiveStepParameters const&
                         prediction_adaptive_step_parameters));
diff --git a/ksp_plugin_test/plugin_integration_test.cpp b/ksp_plugin_test/plugin_integration_test.cpp
index 4e46e47e56..ed272a41de 100644
--- a/ksp_plugin_test/plugin_integration_test.cpp
+++ b/ksp_plugin_test/plugin_integration_test.cpp
@@ -704,10 +704,9 @@ TEST_F(PluginIntegrationTest, Prediction) {
 
   plugin.renderer().SetPlottingFrame(
       plugin.NewBodyCentredNonRotatingNavigationFrame(celestial));
-  plugin.SetPredictionLength(2 * π * Second);
   Ephemeris<Barycentric>::AdaptiveStepParameters adaptive_step_parameters(
       DormandElMikkawyPrince1986RKN434FM<Position<Barycentric>>(),
-      /*max_steps=*/1000,
+      /*max_steps=*/14,
       /*length_integration_tolerance=*/1 * Milli(Metre),
       /*speed_integration_tolerance=*/1 * Milli(Metre) / Second);
   plugin.SetPredictionAdaptiveStepParameters(adaptive_step_parameters);
@@ -739,7 +738,7 @@ TEST_F(PluginIntegrationTest, Prediction) {
       AbsoluteError(rendered_prediction->last().degrees_of_freedom().position(),
                     Displacement<World>({1 * Metre, 0 * Metre, 0 * Metre}) +
                         World::origin),
-      AllOf(Gt(2 * Milli(Metre)), Lt(3 * Milli(Metre))));
+      AllOf(Gt(31 * Milli(Metre)), Lt(32 * Milli(Metre))));
 }
 
 }  // namespace internal_plugin
diff --git a/ksp_plugin_test/plugin_test.cpp b/ksp_plugin_test/plugin_test.cpp
index 93bfd60b08..aca49f0ab4 100644
--- a/ksp_plugin_test/plugin_test.cpp
+++ b/ksp_plugin_test/plugin_test.cpp
@@ -253,43 +253,6 @@ class PluginTest : public testing::Test {
     return time + step * plugin_->Δt();
   }
 
-  // Keeps the vessel with the given |guid| during the next call to
-  // |AdvanceTime|.  The vessel must be present.
-  void KeepVessel(GUID const& guid) {
-    bool inserted;
-    plugin_->InsertOrKeepVessel(guid,
-                                "v" + guid,
-                                SolarSystemFactory::Earth,
-                                /*loaded=*/false,
-                                inserted);
-    EXPECT_FALSE(inserted) << guid;
-  }
-
-  // Inserts a vessel with the given |guid| and makes it a satellite of Earth
-  // with relative position |satellite_initial_displacement_| and velocity
-  // |satellite_initial_velocity_|.  The vessel must not already be present.
-  // Increments the counter |number_of_new_vessels|.
-  void InsertVessel(GUID const& guid,
-                    PartId const& part_id,
-                    std::size_t& number_of_new_vessels,
-                    Instant const& time) {
-    bool inserted;
-    plugin_->InsertOrKeepVessel(guid,
-                                "v" + guid,
-                                SolarSystemFactory::Earth,
-                                /*loaded=*/false,
-                                inserted);
-    EXPECT_TRUE(inserted) << guid;
-    EXPECT_CALL(plugin_->mock_ephemeris(), Prolong(time)).RetiresOnSaturation();
-    plugin_->InsertUnloadedPart(
-        part_id,
-        "p" + std::to_string(part_id),
-        guid,
-        RelativeDegreesOfFreedom<AliceSun>(satellite_initial_displacement_,
-                                           satellite_initial_velocity_));
-    ++number_of_new_vessels;
-  }
-
   void PrintSerializedPlugin(const Plugin& plugin) {
     serialization::Plugin message;
     plugin.WriteToMessage(&message);
@@ -887,13 +850,13 @@ TEST_F(PluginTest, ForgetAllHistoriesBeforeAfterPredictionFork) {
       .WillOnce(DoAll(SaveArg<0>(&trajectories),
                       Return(ByMove(std::move(instance)))));
   EXPECT_CALL(plugin_->mock_ephemeris(), t_max())
-      .WillRepeatedly(Return(Instant()));
+      .WillRepeatedly(Return(Instant() + 12 * Hour));
   EXPECT_CALL(plugin_->mock_ephemeris(), empty()).WillRepeatedly(Return(false));
   EXPECT_CALL(plugin_->mock_ephemeris(), trajectory(_))
       .WillOnce(Return(plugin_->trajectory(SolarSystemFactory::Sun)));
   EXPECT_CALL(plugin_->mock_ephemeris(), Prolong(_)).Times(AnyNumber());
   EXPECT_CALL(plugin_->mock_ephemeris(), FlowWithAdaptiveStep(_, _, _, _, _, _))
-      .WillRepeatedly(DoAll(AppendToDiscreteTrajectory(dof), Return(true)));
+      .WillRepeatedly(DoAll(AppendToDiscreteTrajectory(dof), Return(false)));
   EXPECT_CALL(plugin_->mock_ephemeris(), FlowWithFixedStep(_, _))
       .WillRepeatedly(AppendToDiscreteTrajectory2(&trajectories[0], dof));
   EXPECT_CALL(plugin_->mock_ephemeris(), planetary_integrator())
@@ -1053,6 +1016,7 @@ TEST_F(PluginTest, UpdateCelestialHierarchy) {
         VanishesBefore(initial_from_parent.velocity().Norm(), 718, 422847));
   }
 }
+
 TEST_F(PluginTest, Navball) {
   // Create a plugin with planetarium rotation 0.
   Plugin plugin(initial_time_,
@@ -1101,6 +1065,53 @@ TEST_F(PluginTest, Navball) {
       VanishesBefore(1, 4));
 }
 
+TEST_F(PluginTest, NavballTargetVessel) {
+  GUID const guid = "Target Vessel";
+  PartId const part_id = 666;
+
+  Plugin plugin(initial_time_,
+                initial_time_,
+                0 * Radian);
+
+  serialization::GravityModel::Body gravity_model;
+  CHECK(google::protobuf::TextFormat::ParseFromString(
+      R"(name                    : "Sun"
+         gravitational_parameter : "1 m^3/s^2"
+         reference_instant       : "JD2451545.0"
+         mean_radius             : "1 m"
+         axis_right_ascension    : "0 deg"
+         axis_declination        : "90 deg"
+         reference_angle         : "0 deg"
+         angular_frequency       : "1 rad/s")",
+      &gravity_model));
+  plugin.InsertCelestialAbsoluteCartesian(
+      SolarSystemFactory::Sun,
+      /*parent_index=*/std::experimental::nullopt,
+      gravity_model,
+      solar_system_->cartesian_initial_state_message(
+          SolarSystemFactory::name(SolarSystemFactory::Sun)));
+  plugin.EndInitialization();
+
+  bool inserted;
+  plugin.InsertOrKeepVessel(guid,
+                            "v" + guid,
+                            SolarSystemFactory::Sun,
+                            /*loaded=*/false,
+                            inserted);
+  plugin.InsertUnloadedPart(
+      part_id,
+      "part",
+      guid,
+      RelativeDegreesOfFreedom<AliceSun>(satellite_initial_displacement_,
+                                         satellite_initial_velocity_));
+  plugin.PrepareToReportCollisions();
+  plugin.FreeVesselsAndPartsAndCollectPileUps(20 * Milli(Second));
+
+  plugin.SetTargetVessel(guid, SolarSystemFactory::Sun);
+  plugin.AdvanceTime(plugin.CurrentTime() + 12 * Hour, 0 * Radian);
+  plugin.NavballFrameField(World::origin)->FromThisFrame(World::origin);
+}
+
 TEST_F(PluginTest, Frenet) {
   // Create a plugin with planetarium rotation 0.
   Plugin plugin(initial_time_,
diff --git a/serialization/journal.proto b/serialization/journal.proto
index 915114cae1..d078d259e5 100644
--- a/serialization/journal.proto
+++ b/serialization/journal.proto
@@ -1500,17 +1500,6 @@ message SetPlottingFrame {
   optional Out out = 2;
 }
 
-message SetPredictionLength {
-  extend Method {
-    optional SetPredictionLength extension = 5042;
-  }
-  message In {
-    required fixed64 plugin = 1 [(pointer_to) = "Plugin", (is_subject) = true];
-    required double t = 2;
-  }
-  optional In in = 1;
-}
-
 message SetTargetVessel {
   extend Method {
     optional SetTargetVessel extension = 5121;