diff --git a/src/state.rs b/src/state.rs
index 973cce0d..2501738c 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -304,14 +304,6 @@ pub(crate) struct ProgressDrawState {
 }
 
 impl ProgressDrawState {
-    pub fn clear_term(&self, term: &Term) -> io::Result<()> {
-        term.clear_last_lines(self.lines.len() - self.orphan_lines)
-    }
-
-    pub fn move_cursor(&self, term: &Term) -> io::Result<()> {
-        term.move_cursor_up(self.lines.len() - self.orphan_lines)
-    }
-
     pub fn draw_to_term(&self, term: &Term) -> io::Result<()> {
         for line in &self.lines {
             term.write_line(line)?;
@@ -412,13 +404,16 @@ impl ProgressDrawTarget {
     ///
     /// Will panic if refresh_rate is `Some(0)`. To disable rate limiting use `None` instead.
     pub fn term(term: Term, refresh_rate: impl Into<Option<u64>>) -> ProgressDrawTarget {
-        let rate = refresh_rate.into().map(|x| Duration::from_millis(1000 / x));
+        let rate = refresh_rate
+            .into()
+            .map(|x| Duration::from_millis(1000 / x))
+            .unwrap_or_else(|| Duration::from_secs(0));
         ProgressDrawTarget {
             kind: ProgressDrawTargetKind::Term {
                 term,
-                last_state: None,
+                last_line_count: 0,
                 rate,
-                last_draw: None,
+                last_draw: Instant::now() - rate,
             },
         }
     }
@@ -462,27 +457,24 @@ impl ProgressDrawTarget {
         match self.kind {
             ProgressDrawTargetKind::Term {
                 ref term,
-                ref mut last_state,
+                ref mut last_line_count,
                 rate,
                 ref mut last_draw,
             } => {
                 if draw_state.finished
                     || draw_state.force_draw
-                    || rate.is_none()
-                    || last_draw.is_none()
-                    || last_draw.unwrap().elapsed() > rate.unwrap()
+                    || rate == Duration::from_secs(0)
+                    || last_draw.elapsed() > rate
                 {
-                    if let Some(ref last_state) = *last_state {
-                        if !draw_state.lines.is_empty() && draw_state.move_cursor {
-                            last_state.move_cursor(term)?;
-                        } else {
-                            last_state.clear_term(term)?;
-                        }
+                    if !draw_state.lines.is_empty() && draw_state.move_cursor {
+                        term.move_cursor_up(*last_line_count)?;
+                    } else {
+                        term.clear_last_lines(*last_line_count)?;
                     }
                     draw_state.draw_to_term(term)?;
                     term.flush()?;
-                    *last_state = Some(draw_state);
-                    *last_draw = Some(Instant::now());
+                    *last_line_count = draw_state.lines.len() - draw_state.orphan_lines;
+                    *last_draw = Instant::now();
                 }
             }
             ProgressDrawTargetKind::Remote { idx, ref chan, .. } => {
@@ -523,9 +515,9 @@ impl ProgressDrawTarget {
 pub(crate) enum ProgressDrawTargetKind {
     Term {
         term: Term,
-        last_state: Option<ProgressDrawState>,
-        rate: Option<Duration>,
-        last_draw: Option<Instant>,
+        last_line_count: usize,
+        rate: Duration,
+        last_draw: Instant,
     },
     Remote {
         state: Arc<RwLock<MultiProgressState>>,