
<p>Först ut var <strong>Oneiromancer</strong> (e. Walner-Gone Baby Gone) och för Johnathan Ahle avlade det tvååriga stoet maiden i sin sjätte start och vann med en dryg längd på 1.13,0. Förstapriset uppgick till 5.250 dollar.</p>



<p>Tristan Sjöberg både äger och har fött upp stoet, vars ostartade mor <strong>Gone Baby Gone</strong> (e. Muscle Hill) har sina främsta avkommor i <strong>Kierkegaard K</strong> (e. Chapter Seven), 1.08,7/$459.999, och <strong>Memento Mori</strong> (e. Chapter Seven), 1.09,5/$244.960.</p>



<h2 class="wp-block-heading">Utklassade motståndarna med 17 längder</h2>



<p>Tristan Sjöberg kunde räkna in ytterligare en vinst som uppfödare och ägare när <strong>Nehalennia </strong>(e. Walner-Felicity Shagwell) utklassade sin motståndare med 17 längder (!) från ledningen.</p>



<p>Johnathan Ahle skötte tömmarna och det treåriga stoet kom hem på 1.11,0 och erhöll 5.250 dollar för den överlägsna vinsten. Det var karriärens första triumf i tionde starten och sedan tidigare har hon fyra andraplatser också.</p>



<p>Svenskfödda modern <strong>Felicity Shagwell</strong> (e. Maharajah), 1.08,6/$525.800, vann Breeders Crown ($300.000) för äldre ston. Två startande avkommor har hon och ett år yngre <strong>The Gisbsonia Man</strong> (e. Captain Corey), 1.14,0/$7.000, har startat sex gånger utan att vinna lopp.</p>



<h2 class="wp-block-heading">Andra årssegern</h2>



<p>Delägare är också Tristan Sjöberg i svenskfödde <strong>Big Time Trot </strong>(e. Captain Corey-The Grand Filly) och han spurtvann med trekvarts längd för Johnathan Ahle på 1.12,0 och hämtade hem 6.000 dollar i karriärens andra triumf på sju starter. Bland delägarna finns också Åke Svanstedt, Srf Stable och Midnight Sun Partners.</p>



<p>Förra året såldes Big Time Trot för 600.000 kronor på Solvalla Yearling Sale och Big Time Trot är uppfödd av Ove Karlsson och Robert Lindström.</p>



<p>USA-födda modern <strong>The Grand Filly </strong>(e. Muscle Mass), 1.11,0/$118.263, har tidigare lämnat <strong>Great Time Trot </strong>(e. Walner), 1.09,6ak/1.745.000 kr, och <strong>Domino Time Trot</strong> (e. International Moni), 1.11,6ak/950.900 kr.</p>



<p>För egen del är The Grand Filly helsyster med<strong> Grandma Heidi,</strong> 1.09,0*/$271.247, och i samma syskonskara ingår <strong>Mystical Mission</strong> (e. Manofmanymissions), 1.10,9/$92.554.</p>



<h2 class="wp-block-heading">Första årssegern</h2>



<p>Därefter blev det seger för <strong>Modesty Blaise</strong> (e. Chapter Seven-Different) och Johnathan Ahle. Duon vann med 3,5 längder från ledningen och det treåriga stoet tjänade 6.000 dollar när hon landade på 1.11,5.</p>



<p>Lennart Ågren både äger och har fött upp Modesty Blaise, vilken räknade in årets första vinst i tionde starten. Ifjol vann hon två av åtta lopp.</p>



<p>Modern <strong>Diffident </strong>(e. Father Patrick), 1.11,2/$82.644, tränades också av Åke Svanstedt och Anette Lorentzon. Hon vann fyra lopp på 23 starter och Modesty Blaise är hennes första avkomma.</p>



<p>Femte segern tog Johnathan Ahle bakom <strong>Rambo Hanover</strong> (e. Muscle Hill-Riding High) och den treårige valacken gjorde sitt dagsverke från spets. Med 1,75 längder blev det vinst på 1.11,7. Bland delägarna finns Brochart Stable och Åke Svanstedt. Triumfen värderades till 6.750 dollar och det var fjärde årssegern i femte starten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/wb081525r7rambohanover-617x346.jpg" alt="" class="wp-image-756132"/><figcaption class="wp-element-caption">Rambo Hanover och Åke Svanstedt vid en tidigare seger.  Foto: Lisa Photo</figcaption></figure>



<p>Som ettåring kostade Rambo Hanover 385.000 dollar på Lexington Selected Yearling Sale. Modern <strong>Riding High</strong> (e. Walner), 1.12,1/$13.988, har sin första avkomma i Rambo Hanover.</p>



<p>För egen del nådde hon en andraplats som bäst på tio starter. Riding High är i sin tur halvsyster med <strong>Prospect Park</strong> (e. Father Patrick), 1.11,4/$76.699, och<strong> Park Slope</strong> (e. Chapter Seven), 1.11,0*/$72.593.</p>



<h2 class="wp-block-heading">Nyförvärv vann med fem längder</h2>



<p><strong>French Mistress </strong>(e. Walner-Quickest Hanover) inledde för Petter Engblom och Corey Callahan guidade det tvååriga stoet till vinst från ledningen. På upploppet försvann hon med fem längder på 1.11,5. Belöningen var 6.000 dollar när tog sin tredje seger i karriären.</p>



<p>Igår debuterade hon för Petter Engblom och tidigare har hon tränats av Nifty Norman. Ifjol såldes stoet i Harrisburg för 30.000 dollar. Hon är undan <strong>Quickest Hanover </strong>(e. Father Patrick-Queen of Grace), 1.11,0/$43.349, och har sin första startande avkomma i French Mistress.</p>



<p>Modern är halvsyster med världsrekordhållaren <strong>Lifetime Pursuit </strong>(e. Cantab Hall), 1.08,6/$1.065.586, och i samma syskonskara ingår också <strong>Royal Charm</strong> ($294.038), <strong>Quebec Hanover</strong> ($281.755) och <strong>Broadway Prince</strong> ($141.876).</p>



<p>Vinst blev det även för Petter Engbloms treåring <strong>Trillion Times </strong>(e. Tactical Landing-Insurrection) och Simon Allard. Efter en resa i vinnarhålet blev det seger med en kvarts längd på 1.10,5 för den Engblom Farm-delägde hingsten. Förstapriset uppgick till 6.750 dollar och det var fjärde årssegern på 18 starter.</p>



<p>Trillion Times kostade 20.000 dollar på Lexington Selected Yearling Sale och han är undan fransyskan <strong>Insurrection</strong> (e. Prodigious), 1.15,2am/€31.100, och hennes första avkomma.</p>



<p>Mormor <strong>Rebelle </strong>(e. Defi d’Aunou), 1.16,0l/€84.100, har varit en riktig plusvariant i avelsboxen med avkommor som <strong>Douce Rebelle</strong> (€242.700), Brooks (€159.870), <strong>Clarabelle</strong> (€155.410), <strong>Jirobello</strong> (€108.480) och <strong>Espoir Fou</strong> (€101.380).</p>



<h2 class="wp-block-heading">Ny seger för Tristan Sjöberg</h2>



<p>Ytterligare en vinnare var Tristan Sjöberg inblandad i som delägare. Julie Miller-tränade <strong>My Degenerate</strong> (e. Muscle Hill-Decadence) och Tyler Miller var dagssnabbast när den fyraårige valacken avgjorde med trekvarts längd i spurten på 1.09,3.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/10/mydegenerateoct7.jpg" alt="" class="wp-image-777437"/><figcaption class="wp-element-caption">My Degenerate vinner för Andy Miller. Foto: Tom Melanson</figcaption></figure>



<p>Förstapriset uppgick till 8.000 dollar och My Degenerate tog sin sjunde seger för säsongen.</p>



<p>Han är undan<strong> Decadence </strong>(e. Donato Hanover), 1.10,2/$70.944, vilken tränades av Jonas Czernyson. Modern har två avkommor sedan tidigare; <strong>Penelope J</strong> (e. Walner), 1.09,5/$128.132, och <strong>Lavishness </strong>(e. Muscle Hilll), 1.10,7/$31.088.</p>



<p>En vinst som uppfödare blev det också för Stefan ”Order By Stable” Balazsi när <strong>Verse Nine</strong> (e. Gimpanzee-Acorn Kronos) vann för Patrick Ryder på 1.11,4. Vinstmarginalen mättes ut till 3,75 längder och förstapriset uppgick till 6.000 dollar. Den fyraårige valacken tog sin tredje seger för säsongen på 15 starter.</p>



<p>Som ettåring klubbades han för 225.000 dollar i Harrisburg. Han är undan <strong>Acorn Kronos</strong> (e. Trixton), 1.17,5m/3.800 kr och halvbror med <strong>Happy Chopper </strong>(e. Father Patrick), 1.10,4/$207.017.</p>



<h2 class="wp-block-heading">Uppfödarvinst för Srf Stable</h2>



<p>Lennart ”Srf Stable” Ågren kunde glädja sig åt en seger som uppfödare på Batavia Downs och där vann <strong>Captain Chesley</strong> (e. Tactical Landing-Magical Lady) för Kyle Cummings med en halv längd på 1.15,7.</p>



<p>Belöningen för den sexårige valacken var 4.000 dollar och det var tredje segern för året på 23 starter. Modern <strong>Magical Lady </strong>(e. Kadabra), 1.11,5/$90.621, har också lämnat <strong>Shirin</strong> (e. Chapter Seven), 1.12,5*/$53.989.</p>



<p>Tristan Sjöberg hade också en uppfödning som vann på Dayton Raceway igår. <strong>Nihilst</strong> (e. Six Pack-Do You Believe) vann för Trevor Smith och från spets stack det treåriga stoet ifrån med närmare fyra längder på 1.13,1. Joe Putnam tränar och förstapriset uppgick till 7.250 dollar. Två segrar har det blivit på 13 starter i år.</p>



<p>Stoet såldes i Lexington som ettåring för 7.000 dollar. Hon är undan <strong>Do You Believe</strong> (e. Crazed), 1.11,6/$54.466, vilken har sin främsta avkomma i <strong>Immanuel K</strong> (e. Sebastian K.), 1.09,7/$204.502.</p>



<p>På samma bana vann också Perry Söderbergs deluppfödda <strong>Moni Legend</strong> (e. International Moni-Urban Legend) på 1.14,5 efter en resa i tredje inner. Det tvååriga stoet avgjorde med 1,75 längder och tjänade 7.250 dollar när hon avlade maiden i sin åttonde start.</p>



<p>Ifjol såldes hon för 25.000 dollar på Lexington Selected Yearling Sale. Modern <strong>Urban Legend</strong> (e. Muscle Hill), 1.09,9/$35.550, har tidigare lämnat <strong>Boots N Beer</strong> (e. Greenshoe), 1,09,2*/$185.247.</p>



<h2 class="wp-block-heading">Svanstedt i topp</h2>



<p>Åke Svanstedt hade också en deluppfödd travare som vann på Plainridge Park. Jay Randall skötte tömmarna bakom <strong>Wall Street Edge</strong> (e. Walner-Evelyn) och duon avgjorde med en kvarts längd på 1.11,4 efter en resa i vinnarhålet. Förstapriset uppgick till 10.000 dollar. I år har det blivit sex segrar på 24 starter.</p>



<p>Wall Street Edge såldes som ettåring för 55.000 dollar i Lexington. Modern<strong> Evelyn</strong> (e. Muscle Hill), 1.09,9/$305.222, tävlade för Åke Svanstedt och Wall Street Edge är hennes främsta avkomma.</p>



<p>Själv är hon undan <strong>Viva Las Lindy</strong> (e. Dream Vacation), 1.11,5/$167.222, och ingår i samma syskonskara som <strong>Nomophobia</strong> ($138.653), <strong>Hannah</strong> ($133.873), <strong>Gerry </strong>($124.514) och <strong>Dream Child</strong> ($107.556).</p>



<h2 class="wp-block-heading">Blågult på Yonkers Raceway</h2>



<p>Stefan Balazsi hade också en uppfödning som vann på Yonkers Raceway. <strong>All Too Well</strong> (e. Muscle Hill-Order By Wish) avgjorde med hals för Yogi Sheridan efter ett lopp i rygg på ledaren på 1.14,0 och belönades med 6.550 dollar. Den femårige valacken har vunnit fyra av 23 starter i år.</p>



<p>Som ettåring klubbades All Too Well för 150.000 dollar i Harrisburg. Modern <strong>Order By Wish</strong> (e. Cantab Hall), 1.12,5*/$35.469, startade fem gånger och vann ett lopp – försök i Pennsylvania Sire Stakes – innan hon gick till avel.</p>



<p>Hon har sina främsta avkommor i <strong>Rome Pays Off</strong> (e. Muscle Hill), 1.09,7ak/6.500.187 kr, avelshingsten <strong>Marseille</strong> (e. Muscle Hill), 1.08,9/$518.285, och <strong>Wishful Order </strong>(e. Muscle Hill), 1.10,8am/1.465.448 kr.</p>



<p>Svenskfödde <strong>Bellissimo Face</strong> (e. Raja Mirchi-Marita’s Legacy) vann för Tyler Buter på Yonkers Raceway från ledningen med trekvarts längd på 1.11,8. Lutfi Kolgjini och Anna Svenssons uppfödning belönades med 11.000 dollar när den sjuårige valacken tog sin fjärde årsseger i tolfte starten.</p>



<p>Bellissimo Face är undan <strong>Marita’s Legacy</strong> (e. Yankee Glide), vilken också lämnat <strong>Xia Lloyd</strong> (e. Raja Mirchi), 1.11,2ak/1.135.000 kr.</p>



<h2 class="wp-block-heading">Dubbel till Engblom</h2>



<p>Petter Engblom hade dubbla vinnare. Jason Bartlett skötte tömmarna bakom <strong>Kildare King </strong>(e. Trixton-Exclusivity) och från spets blev det vinst med en längd på 1.12,0.</p>



<p>Vinsten värderades till 14.000 dollar och det var sjunde triumfen i år på 22 starter. Bland delägarna finns Engblom Farm.</p>



<p>Vann gjorde även <strong>Devillish Hill</strong> (e. Muscle Hill-Devilish Delight) och den sexårige valacken försvann med fyra längder för Jason Bartlett på 1.10,5. Belöningen var 14.000 dollar.</p>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="nrypQ2DCJN"><a href="https://sulkysport.se/toppspurt-till-seger-7/">Toppspurt till seger</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Toppspurt till seger” &ndash; Sulkysport" src="https://sulkysport.se/toppspurt-till-seger-7/embed/#?secret=TOoUeodW9B#?secret=nrypQ2DCJN" data-secret="nrypQ2DCJN" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
