diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ea7afb..fcc028f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.29.1] - 2024-10-02
+
+Fix [issue #176](https://github.com/emabee/flexi_logger/issues/176):
+leading underscore in log file name if only the infix is used (no basename, no start time, no discriminant).
+
 ## [0.29.0] - 2024-08-25
 
 Revised `SyslogWriter` (-> version bump): introduced builder pattern,
diff --git a/Cargo.toml b/Cargo.toml
index 6276c0d..c8c37e1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "flexi_logger"
-version = "0.29.0"
+version = "0.29.1"
 authors = ["emabee <meinolf.block@sap.com>"]
 categories = ["development-tools::debugging"]
 description = """
diff --git a/src/parameters/file_spec.rs b/src/parameters/file_spec.rs
index b49d79f..de49447 100644
--- a/src/parameters/file_spec.rs
+++ b/src/parameters/file_spec.rs
@@ -4,13 +4,26 @@ use std::path::{Path, PathBuf};
 
 /// Builder object for specifying the name and path of the log output file.
 ///
-/// The filename is built from several partially optional components, using this pattern:
+/// The filename is built from several partially components, using this pattern:
 ///
-/// ```<basename>[_<discriminant>][_<date>_<time>][_infix][.<suffix>]```
+/// ```<filename> = [<basename>][_][<discriminant>][_][<starttime>][_][<infix>][.<suffix>]```
 ///
-/// The default filename pattern without rotation uses the program name as basename,
-/// no discriminant, the timestamp of the program start, and the suffix `.log`,
-/// e.g.
+/// - `[<basename>]`: This is by default the program's name, but can be set to a different value
+///   or suppressed at all.
+///
+/// - `[_]`: Consecutive name parts are separated by an underscore.
+///   No underscore is used at the beginning of the filename and directly before the suffix.
+///
+/// - `[<discriminant>]`: some optional name part that allows further differentiations.
+///
+/// - `[<starttime>]`: denotes the point in time when the program was started, if used.
+///
+/// - `[infix]`: used with rotation to differentiate consecutive files.
+///
+/// Without rotation, the default filename pattern uses the program name as basename,
+/// no discriminant, the timestamp of the program start
+/// (printed in the format "YYYY-MM-DD_hh-mm-ss"),
+/// and the suffix `.log`, e.g.
 ///
 /// ```myprog_2015-07-08_10-44-11.log```.
 ///
@@ -18,14 +31,14 @@ use std::path::{Path, PathBuf};
 /// be associated with a concrete program run.
 ///
 /// When the timestamp is suppressed with [`FileSpec::suppress_timestamp`],
-/// you get a fixed output file.
+/// you get a fixed output file name.
 /// It is then worth considering whether a new program start should discard
 /// the content of an already existing outputfile or if it should append its new content to it
 /// (see [`Logger::append`](crate::Logger::append)).
 ///
-/// With rotation the timestamp is by default suppressed and instead the infix is used.
-/// The infix always starts with "_r". For more details how its precise content can be influenced,
-/// see [`Naming`](crate::Naming).
+/// With rotation, the timestamp is by default suppressed and instead the infix is used.
+/// The infix starts always with "r".
+/// For more details how its precise content can be influenced, see [`Naming`](crate::Naming).
 ///
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct FileSpec {
@@ -169,7 +182,7 @@ impl FileSpec {
         self
     }
 
-    /// Makes the logger not include a timestamp into the names of the log files
+    /// Makes the logger not include the start time into the names of the log files
     ///
     /// Equivalent to `use_timestamp(false)`.
     #[must_use]
@@ -177,7 +190,7 @@ impl FileSpec {
         self.use_timestamp(false)
     }
 
-    /// Defines if a timestamp should be included into the names of the log files.
+    /// Defines if the start time should be included into the names of the log files.
     ///
     /// The _default_ behavior depends on the usage:
     /// - without rotation, a timestamp is by default included into the name
@@ -192,6 +205,21 @@ impl FileSpec {
         self
     }
 
+    #[doc(hidden)]
+    #[must_use]
+    pub fn used_directory(&self) -> PathBuf {
+        self.directory.clone()
+    }
+    pub(crate) fn has_basename(&self) -> bool {
+        !self.basename.is_empty()
+    }
+    pub(crate) fn has_discriminant(&self) -> bool {
+        self.o_discriminant.is_some()
+    }
+    pub(crate) fn uses_timestamp(&self) -> bool {
+        matches!(self.timestamp_cfg, TimestampCfg::Yes)
+    }
+
     // If no decision was done yet, decide now whether to include a timestamp
     // into the names of the log files.
     pub(crate) fn if_default_use_timestamp(&mut self, use_timestamp: bool) {
@@ -213,9 +241,6 @@ impl FileSpec {
     }
 
     /// Derives a `PathBuf` from the spec and the given infix.
-    ///
-    /// It is composed like this:
-    ///  `<directory>/<basename>_<discr>_<timestamp><infix>.<suffix>`
     #[must_use]
     pub fn as_pathbuf(&self, o_infix: Option<&str>) -> PathBuf {
         let mut filename = self.basename.clone();
@@ -230,6 +255,7 @@ impl FileSpec {
             filename.push_str(timestamp);
         }
         if let Some(infix) = o_infix {
+            FileSpec::separate_with_underscore(&mut filename);
             filename.push_str(infix);
         };
         if let Some(suffix) = &self.o_suffix {
@@ -248,7 +274,7 @@ impl FileSpec {
         }
     }
 
-    // <directory>/<basename>_<discr>_<timestamp><infix_pattern>.<suffix>
+    // <directory>/[<basename>][_][<discriminant>][_][<starttime>][_][<infix_pattern>]
     pub(crate) fn as_glob_pattern(&self, infix_pattern: &str, o_suffix: Option<&str>) -> String {
         let mut filename = self.basename.clone();
         filename.reserve(50);
@@ -261,6 +287,8 @@ impl FileSpec {
             FileSpec::separate_with_underscore(&mut filename);
             filename.push_str(timestamp);
         }
+
+        FileSpec::separate_with_underscore(&mut filename);
         filename.push_str(infix_pattern);
 
         match o_suffix {
diff --git a/src/writers/file_log_writer/state.rs b/src/writers/file_log_writer/state.rs
index e914f7b..10ea54f 100644
--- a/src/writers/file_log_writer/state.rs
+++ b/src/writers/file_log_writer/state.rs
@@ -17,8 +17,8 @@ use std::{
     sync::{Arc, Mutex},
 };
 use timestamps::{
-    collision_free_infix_for_rotated_file, infix_from_timestamp, latest_timestamp_file,
-    rcurrents_creation_timestamp,
+    collision_free_infix_for_rotated_file, creation_timestamp_of_currentfile, infix_from_timestamp,
+    latest_timestamp_file,
 };
 
 #[cfg(feature = "async")]
@@ -34,7 +34,7 @@ use {
 #[cfg(feature = "async")]
 const ASYNC_WRITER: &str = "flexi_logger-fs-async_writer";
 
-const CURRENT_INFIX: &str = "_rCURRENT";
+const CURRENT_INFIX: &str = "rCURRENT";
 
 #[derive(Debug)]
 enum NamingState {
@@ -64,11 +64,9 @@ pub(super) enum InfixFormat {
     Custom(String),
 }
 impl InfixFormat {
-    const STD_INFIX_FORMAT: &'static str = "_r%Y-%m-%d_%H-%M-%S";
-    pub(super) fn custom(f: &str) -> Self {
-        let mut fmt = "_".to_string();
-        fmt.push_str(f);
-        Self::Custom(fmt)
+    const STD_INFIX_FORMAT: &'static str = "r%Y-%m-%d_%H-%M-%S";
+    pub(super) fn custom(fmt: &str) -> Self {
+        Self::Custom(fmt.to_string())
     }
     fn format(&self) -> &str {
         match self {
@@ -306,7 +304,7 @@ impl State {
             }
             Naming::Timestamps => (
                 NamingState::Timestamps(
-                    rcurrents_creation_timestamp(
+                    creation_timestamp_of_currentfile(
                         &self.config,
                         CURRENT_INFIX,
                         !self.config.append,
@@ -323,9 +321,9 @@ impl State {
                 format: ts_fmt,
             } => {
                 if let Some(current_token) = o_current_token {
-                    let current_infix = prepend_underscore(current_token);
+                    let current_infix = current_token.to_string();
                     let naming_state = NamingState::Timestamps(
-                        rcurrents_creation_timestamp(
+                        creation_timestamp_of_currentfile(
                             &self.config,
                             &current_infix,
                             !self.config.append,
@@ -426,7 +424,7 @@ impl State {
                 let infix = match rotation_state.naming_state {
                     NamingState::Timestamps(ref mut ts, ref o_current_infix, ref fmt) => {
                         if let Some(current_infix) = o_current_infix {
-                            *ts = rcurrents_creation_timestamp(
+                            *ts = creation_timestamp_of_currentfile(
                                 &self.config,
                                 current_infix,
                                 true,
@@ -551,16 +549,6 @@ impl State {
     }
 }
 
-fn prepend_underscore(infix: &str) -> String {
-    if infix.is_empty() {
-        infix.to_string()
-    } else {
-        let mut infix_with_underscore = "_".to_string();
-        infix_with_underscore.push_str(infix);
-        infix_with_underscore
-    }
-}
-
 fn validate_logs_in_file(
     reader: &mut dyn BufRead,
     path: &Path,
diff --git a/src/writers/file_log_writer/state/list_and_cleanup.rs b/src/writers/file_log_writer/state/list_and_cleanup.rs
index 5d30712..26ce680 100644
--- a/src/writers/file_log_writer/state/list_and_cleanup.rs
+++ b/src/writers/file_log_writer/state/list_and_cleanup.rs
@@ -6,7 +6,7 @@ use std::{
     thread::{Builder as ThreadBuilder, JoinHandle},
 };
 
-const INFIX_PATTERN: &str = "_r[0-9]*";
+const INFIX_PATTERN: &str = "r[0-9]*";
 
 pub(super) fn existing_log_files(
     file_spec: &FileSpec,
diff --git a/src/writers/file_log_writer/state/numbers.rs b/src/writers/file_log_writer/state/numbers.rs
index 0a58f51..b4986ad 100644
--- a/src/writers/file_log_writer/state/numbers.rs
+++ b/src/writers/file_log_writer/state/numbers.rs
@@ -4,7 +4,7 @@ use crate::{writers::FileLogWriterConfig, FileSpec};
 use std::cmp::max;
 
 pub(super) fn number_infix(idx: u32) -> String {
-    format!("_r{idx:0>5}")
+    format!("r{idx:0>5}")
 }
 
 pub(super) fn index_for_rcurrent(
@@ -41,18 +41,26 @@ pub(super) fn index_for_rcurrent(
 pub(super) fn get_highest_index(file_spec: &FileSpec) -> Option<u32> {
     let mut o_highest_idx = None;
     for file in super::list_and_cleanup::list_of_log_and_compressed_files(file_spec) {
-        let filename = file.file_stem().unwrap(/*ok*/).to_string_lossy();
-        let mut it = filename.rsplit("_r");
-        match it.next() {
-            Some(next) => {
-                let idx: u32 = next.parse().unwrap_or(0);
-                o_highest_idx = match o_highest_idx {
-                    None => Some(idx),
-                    Some(prev) => Some(max(prev, idx)),
-                };
+        let name = file.file_stem().unwrap(/*ok*/).to_string_lossy();
+        let infix = if file_spec.has_basename()
+            || file_spec.has_discriminant()
+            || file_spec.uses_timestamp()
+        {
+            // infix is the last, but not the first part of the name, starts with _r
+            match name.rsplit("_r").next() {
+                Some(infix) => infix,
+                None => continue, // ignore unexpected files
             }
-            None => continue, // ignore unexpected files
-        }
+        } else {
+            // infix is the only part of the name, just skip over the r
+            &name[1..]
+        };
+
+        let idx: u32 = infix.parse().unwrap_or(0);
+        o_highest_idx = match o_highest_idx {
+            None => Some(idx),
+            Some(prev) => Some(max(prev, idx)),
+        };
     }
     o_highest_idx
 }
diff --git a/src/writers/file_log_writer/state/timestamps.rs b/src/writers/file_log_writer/state/timestamps.rs
index f6950ff..dec61f8 100644
--- a/src/writers/file_log_writer/state/timestamps.rs
+++ b/src/writers/file_log_writer/state/timestamps.rs
@@ -1,8 +1,10 @@
 use super::{get_creation_timestamp, list_and_cleanup::list_of_infix_files, InfixFormat};
 use crate::{writers::FileLogWriterConfig, FileSpec};
 use chrono::{DateTime, Local, NaiveDateTime, TimeZone};
-use std::path::Path;
-use std::{ops::Add, path::PathBuf};
+use std::{
+    ops::Add,
+    path::{Path, PathBuf},
+};
 
 pub(super) fn infix_from_timestamp(
     ts: &DateTime<Local>,
@@ -19,11 +21,11 @@ pub(super) fn infix_from_timestamp(
 
 fn ts_infix_from_path(path: &Path, file_spec: &FileSpec) -> String {
     let idx = file_spec
-        .as_pathbuf(Some("_rXXXXX"))
+        .as_pathbuf(Some("rXXXXX"))
         .to_string_lossy()
-        .find("_rXXXXX")
+        .find("rXXXXX")
         .unwrap();
-    String::from_utf8_lossy(&path.to_string_lossy().as_bytes()[idx..idx + 21]).to_string()
+    String::from_utf8_lossy(&path.to_string_lossy().as_bytes()[idx..idx + 20]).to_string()
 }
 fn timestamp_from_ts_infix(infix: &str, fmt: &InfixFormat) -> Option<DateTime<Local>> {
     NaiveDateTime::parse_from_str(infix, fmt.format())
@@ -31,7 +33,7 @@ fn timestamp_from_ts_infix(infix: &str, fmt: &InfixFormat) -> Option<DateTime<Lo
         .and_then(|ts| Local.from_local_datetime(&ts).single())
 }
 
-pub(super) fn rcurrents_creation_timestamp(
+pub(super) fn creation_timestamp_of_currentfile(
     config: &FileLogWriterConfig,
     current_infix: &str,
     rotate_rcurrent: bool,
@@ -168,7 +170,7 @@ mod test {
             .suppress_timestamp();
 
         let now = Local::now();
-        let now = now
+        let now_rounded = now
             .checked_sub_signed(
                 Duration::from_std(std::time::Duration::from_nanos(u64::from(
                     now.timestamp_subsec_nanos(),
@@ -176,8 +178,9 @@ mod test {
                 .unwrap(),
             )
             .unwrap();
+
         let paths: Vec<PathBuf> = (0..10)
-            .map(|i| now - Duration::try_seconds(i).unwrap())
+            .map(|i| now_rounded - Duration::try_seconds(i).unwrap())
             .map(|ts| {
                 file_spec.as_pathbuf(Some(&super::infix_from_timestamp(
                     &ts,
@@ -187,21 +190,23 @@ mod test {
             })
             .collect();
 
+        let newest = paths
+            .iter()
+            // retrieve the infix
+            .map(|path| super::ts_infix_from_path(path, &file_spec))
+            // parse infix as date, ignore all files where this fails,
+            .filter_map(|infix| super::timestamp_from_ts_infix(&infix, &InfixFormat::Std))
+            // take the newest of these dates
+            .reduce(|acc, e| if acc > e { acc } else { e })
+            // if nothing is found, take Local::now()
+            .unwrap_or_else(Local::now);
+
         assert_eq!(
-            now,
+            now_rounded,
             // TODO: use mocking to avoid code duplication:
             // this test is only useful if the path evaluation is the same as in
             // super::latest_timestamp_file()
-            paths
-                .iter()
-                // retrieve the infix
-                .map(|path| super::ts_infix_from_path(path, &file_spec))
-                // parse infix as date, ignore all files where this fails,
-                .filter_map(|infix| super::timestamp_from_ts_infix(&infix, &InfixFormat::Std))
-                // take the newest of these dates
-                .reduce(|acc, e| if acc > e { acc } else { e })
-                // if nothing is found, take Local::now()
-                .unwrap_or_else(Local::now)
+            newest
         );
     }
 }
diff --git a/tests/test_rotate_immediate_compression.rs b/tests/test_rotate_immediate_compression.rs
index 2ffbda5..28fe1f0 100644
--- a/tests/test_rotate_immediate_compression.rs
+++ b/tests/test_rotate_immediate_compression.rs
@@ -51,39 +51,44 @@ fn test_variant(naming: Naming, criterion: Criterion, cleanup: Cleanup) {
 
     test_utils::wait_for_start_of_second();
 
-    let logger = Logger::try_with_str("trace")
-        .unwrap()
-        .log_to_file(FileSpec::default().directory(&directory))
-        .format_for_files(flexi_logger::detailed_format)
-        .format_for_stderr(flexi_logger::detailed_format)
-        .duplicate_to_stderr(Duplicate::Info)
-        .rotate(criterion, naming, cleanup)
-        .start()
-        .unwrap_or_else(|e| panic!("Logger initialization failed with {e}"));
-
-    info!(
-        "test correct rotation by {}",
-        match criterion {
-            Criterion::Age(_) => "age",
-            Criterion::AgeOrSize(_, _) => "age or size",
-            Criterion::Size(_) => "size",
-        }
-    );
     let mut written_lines = 1;
+    {
+        let logger = Logger::try_with_str("trace")
+            .unwrap()
+            .log_to_file(
+                FileSpec::default()
+                    .directory(&directory)
+                    .suppress_basename(),
+            )
+            .format_for_files(flexi_logger::detailed_format)
+            .format_for_stderr(flexi_logger::detailed_format)
+            .duplicate_to_stderr(Duplicate::Info)
+            .rotate(criterion, naming, cleanup)
+            .start()
+            .unwrap_or_else(|e| panic!("Logger initialization failed with {e}"));
+
+        info!(
+            "test correct rotation by {}",
+            match criterion {
+                Criterion::Age(_) => "age",
+                Criterion::AgeOrSize(_, _) => "age or size",
+                Criterion::Size(_) => "size",
+            }
+        );
 
-    let start = Instant::now();
-    let max_runtime = Duration::from_millis(3_200);
-    let sleep_time = Duration::from_millis(7);
-    while Instant::now() - start < max_runtime {
-        written_lines += 1;
-        if written_lines % 17 == 4 {
-            logger.trigger_rotation().unwrap();
+        let start = Instant::now();
+        let max_runtime = Duration::from_millis(1_200);
+        let sleep_time = Duration::from_millis(7);
+        while Instant::now() - start < max_runtime {
+            written_lines += 1;
+            if written_lines % 17 == 4 {
+                logger.trigger_rotation().unwrap();
+            }
+            trace!("line_count = {written_lines}");
+            std::thread::sleep(sleep_time);
         }
-        trace!("line_count = {written_lines}");
-        std::thread::sleep(sleep_time);
     }
 
-    std::thread::sleep(std::time::Duration::from_millis(100));
     let read_lines = test_utils::count_log_lines(&directory);
     assert_eq!(
         read_lines, written_lines,
diff --git a/tests/test_rotate_naming_variants.rs b/tests/test_rotate_naming_variants.rs
index 8b1a182..c14e639 100644
--- a/tests/test_rotate_naming_variants.rs
+++ b/tests/test_rotate_naming_variants.rs
@@ -1,18 +1,17 @@
 mod test_utils;
 
+use flexi_logger::{Age, Cleanup, Criterion, Duplicate, FileSpec, Logger, Naming};
+use glob::glob;
+use log::*;
 use std::{
     fs::File,
     io::{BufRead, BufReader},
     ops::Add,
     path::Path,
+    time::{Duration, Instant},
 };
 
-use chrono::Local;
-use flexi_logger::{Age, Cleanup, Criterion, Duplicate, FileSpec, Logger, Naming};
-use glob::glob;
-use log::*;
-
-const COUNT: u8 = 10;
+const COUNT: u8 = 13;
 
 #[test]
 fn test_rotate_naming_variants() {
@@ -23,21 +22,42 @@ fn test_rotate_naming_variants() {
 }
 
 fn work(value: u8) {
+    let directory = test_utils::dir();
+
     match value {
-        0 => test_variant(Naming::Timestamps, Criterion::AgeOrSize(Age::Second, 200)),
+        0 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::Timestamps,
+            Criterion::AgeOrSize(Age::Second, 200),
+        ),
         1 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
             Naming::TimestampsDirect,
             Criterion::AgeOrSize(Age::Second, 200),
         ),
-        2 => test_variant(Naming::Numbers, Criterion::AgeOrSize(Age::Second, 200)),
+        2 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::Numbers,
+            Criterion::AgeOrSize(Age::Second, 200),
+        ),
         3 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
             Naming::NumbersDirect,
             Criterion::AgeOrSize(Age::Second, 200),
         ),
 
-        4 => test_variant(Naming::Timestamps, Criterion::Age(Age::Second)),
-        5 => test_variant(Naming::TimestampsDirect, Criterion::Age(Age::Second)),
+        4 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::Timestamps,
+            Criterion::Age(Age::Second),
+        ),
+        5 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::TimestampsDirect,
+            Criterion::Age(Age::Second),
+        ),
         6 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
             Naming::TimestampsCustomFormat {
                 current_infix: Some("myCURRENT"),
                 format: "%Y-%m-%d",
@@ -45,26 +65,59 @@ fn work(value: u8) {
             Criterion::Age(Age::Second),
         ),
         7 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
             Naming::TimestampsCustomFormat {
                 current_infix: Some(""),
                 format: "%Y-%m-%d_%H-%M-%S",
             },
             Criterion::Age(Age::Second),
         ),
-        8 => test_variant(Naming::Numbers, Criterion::Age(Age::Second)),
-        9 => test_variant(Naming::NumbersDirect, Criterion::Age(Age::Second)),
+        8 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::Numbers,
+            Criterion::Age(Age::Second),
+        ),
+        9 => test_variant(
+            FileSpec::default().directory(directory.join(value.to_string())),
+            Naming::NumbersDirect,
+            Criterion::Age(Age::Second),
+        ),
+        10 => test_variant(
+            FileSpec::default()
+                .directory(directory.join(value.to_string()))
+                .suppress_basename()
+                .suppress_timestamp()
+                .o_discriminant(Option::<String>::None),
+            Naming::NumbersDirect,
+            Criterion::Age(Age::Second),
+        ),
+        11 => test_variant(
+            FileSpec::default()
+                .directory(directory.join(value.to_string()))
+                .suppress_basename()
+                .suppress_timestamp()
+                .o_discriminant(Option::<String>::None),
+            Naming::Timestamps,
+            Criterion::Age(Age::Second),
+        ),
+        12 => test_variant(
+            FileSpec::default()
+                .directory(directory.join(value.to_string()))
+                .suppress_basename()
+                .suppress_timestamp()
+                .o_discriminant(Option::<String>::None),
+            Naming::Numbers,
+            Criterion::Age(Age::Second),
+        ),
         COUNT..=u8::MAX => unreachable!("Wrong dispatch"),
     }
 }
 
-fn test_variant(naming: Naming, criterion: Criterion) {
-    let directory = test_utils::dir();
-
-    test_utils::wait_for_start_of_second();
-
+fn test_variant(file_spec: FileSpec, naming: Naming, criterion: Criterion) {
+    let directory = file_spec.used_directory();
     let _logger = Logger::try_with_str("trace")
         .unwrap()
-        .log_to_file(FileSpec::default().directory(&directory))
+        .log_to_file(file_spec)
         .format_for_files(flexi_logger::detailed_format)
         .format_for_stderr(flexi_logger::detailed_format)
         .duplicate_to_stderr(Duplicate::Info)
@@ -81,12 +134,13 @@ fn test_variant(naming: Naming, criterion: Criterion) {
         }
     );
     let mut line_count = 1;
-    let start = Local::now();
-    let duration = chrono::Duration::from_std(std::time::Duration::from_secs(10)).unwrap();
-    while Local::now() - start < duration {
+    let start = Instant::now();
+    let max_runtime = Duration::from_millis(3_000);
+    let sleep_time = Duration::from_millis(10);
+    while Instant::now() - start < max_runtime {
         trace!("{}", 'a');
         line_count += 1;
-        std::thread::sleep(std::time::Duration::from_millis(100));
+        std::thread::sleep(sleep_time);
     }
 
     verify_logs(&directory, line_count);