
<p class="has-drop-cap wp-block-paragraph">1Förra året duellerade <strong>Borups Victory</strong> (e. Googoo Gaagaa) och <strong>Francesco Zet</strong> (e. Father Patrick) sida vid sida i Sundsvall Open Trot. Resultatet? Seger för Francesco Zet på nytt världsrekord – 1.09,4a/2.140 meter – medan Borups Victory föll tillbaka till tredjeplatsen. Idag på <strong>Bergsåker </strong>(första start 14.45) möts hästarna igen i samma lopp i kamp om en miljon kronor i förstapris.</p>



<p class="wp-block-paragraph">Elitloppet blev inte vad kretsen kring Francesco Zet hoppats på och nu har han matchats i beskedliga gäng i de senaste starterna.<br>– Han tränade i måndags och var väldigt, väldigt fin. Han fick gå ett tufft jobb och det känns bra att han är redo för att göra en sån där bra prestation igen. Det blir barfota runt om, vilket är första gången sedan Elitloppets final. Norskt huvudlag. Jag är väldigt spänd på att se insatsen. Han har hittat ett väldigt bra flow igen, säger Daniel Redén till Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Borups Victory har inte tävlat sedan segern i Kymi Grand Prix den 14 juni.<br>– Hästen är så oerhört bra. Även fast han inte tävlat på ett tag så tror jag att han kommer att vara riktigt bra. Han kanske inte gör sitt livs lopp, men jag tror att han kommer att göra en bra prestation och visa sig från den sida han brukar visa upp, att han är väldigt bra. Taktik är svårt att prata om. Han har ett bra utgångsläge, så man kan välja lite grann hur man vill lägga upp loppet. Men han har varit bra i ledningen och det är närmaste vägen till mål, säger Daniel Wäjersten till Kanal75.</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna av Sundsvall Open Trot</strong></p>



<ol class="wp-block-list">
<li>2024 – <strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén), 1.09,4</li>



<li>2015 – <strong>Delicious</strong> (e. Cantab Hall) – Örjan Kihlström (Daniel Redén), 1.10,0</li>



<li>2018 – <strong>Milligan&#8217;s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander), 1.10,1</li>



<li>2020 – <strong>Milligan&#8217;s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander), 1.10,6</li>



<li>2013 – <strong>Panne de Moteur</strong> (e. Credit Winner) – Örjan Kihlström (Stefan Hultman), 1.10,9</li>
</ol>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/30v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bergsåkers tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/manlykkea.m.2024-617x333.jpg" alt="" class="wp-image-599068"/><figcaption class="wp-element-caption">Gunnar Melander bakom stjärnan Månlykke A.M. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Det är inte bara Sundsvall Open Trot som bjuder på stor sport denna eftermiddag. Svenskt Mästerskap för kallblod avgörs traditionsenligt samma tävlingsdag och det sker med <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.) som förgrundsfigur i sin comeback efter 4,5 månaders tävlingsuppehåll.</p>



<p class="wp-block-paragraph">Gunnar Melanders häst jagar sin femte seger i loppet och Melander har faktiskt vunnit nio av de tolv senaste upplagorna då Månlykke A.M.:s far <strong>Månprinsen A.M. </strong>slog till vid fem tillfällen mellan 2013 och 2018. Åtta gånger har han kört vinnarna själv, medan Magnus A Djuse lotsade Månlykke A.M. till fjolårsvinsten.</p>



<p class="wp-block-paragraph">Men 2023 års svenske mästare, <strong>Järvsöodin</strong> (e. Järvsöfafs), har inte gett upp hoppet om ett andra SM-guld.<br>– Jag körde bort Järvsöodin i SM förra året – han är bättre än Månlykke A.M. tycker jag, säger kusken Marcus Lilius till Kanal75 om Jan-Olov Persson-tränade Järvsöodin.</p>



<p class="wp-block-paragraph">Det vankas också stor jackpot på V75, där 25 miljoner kronor extra skjutits in i sjurättspotten. <em>”Vi har tre spikar på veckans systemförslag plus att rejäla skrällar jagas i övriga lopp”, </em>skriver Sulkysports expert.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-jag-gar-all-in/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsomgången till dagens jackpottävlingar.</a></p>



<p class="wp-block-paragraph">Lördagen inleds med breddlopp i <strong>Halmstad </strong>(start 11.10) och avslutade med spetsade breddlopp i <strong>Eskilstuna</strong> (första start 18.30).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/250830.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 Idag är <strong>Kilimanjaro Face </strong>(e. Googoo Gaagaa) och Adrian Kolgjini storfavorit till segern i Danskt Stoderby efter ha lekt hem sitt försök på 1.13,5a/2.000 meter. För hästarna som är premichansade – alla utom Karoline Gardenia – väntar ett förstapris på 513.000 danska kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/kilimanjaroface-617x333.jpg" alt="" class="wp-image-739392"/><figcaption class="wp-element-caption">Adrian Kolgjini och  Kilimanjaro Face vid segern i Stosprintern i Halmstad. Foto Lars B Persson</figcaption></figure>



<p class="wp-block-paragraph">Adrian Kolgjini är inte ensam tvåbent svensk i loppet. Thomas Uhrberg kör Karoline Gardenia (e. Great Challenger), Jörgen Sjunnesson sitter upp bakom Karla di Damgård (e. Papagayo E.) och Stefan Persson tar hand om Kleopatra S F (e. Readly Express). Klockan 15.44 släpps fältet iväg på Charlottenlund.</p>



<p class="wp-block-paragraph"><strong>Danskt Stoderby</strong><br>Fyraåriga ston.<br><strong>Förstapris:</strong> 342.000 dkk (513.000 dkk*)<br><em>2.000 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Kusk/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Kaley D C</strong> (e. Wishing Stone) – Michael Lönborg</li>



<li><strong>Karoline Gardenia </strong>(e. Great Challenger) – Thomas Uhrberg/Steen Juul</li>



<li><strong>Kilimanjaro Face</strong> (e. Googoo Gaagaa) – Adrian Kolgjini</li>



<li><strong>Knowyour Shadow </strong>(e. Cantab Hall) – Birger Jörgensen/Morten Juul</li>



<li><strong>Keen Lady Josselyn</strong> (e. Maharajah) – Steen Juul</li>



<li><strong>Karla di Damgård </strong>(e. Papgayo E.) – Jörgen Sjunnesson/Ernst Gamst Nielsen (a)</li>



<li><strong>Kimibi Kini</strong> (e. Great Challenger) – Henrik Lönborg/Kaj Jensen</li>



<li><strong>Kissingstone Engel</strong> (e. Wishing Stone) – Sören Johansson</li>



<li><strong>Kirsten Tinghöj </strong>(e. Dominion Beach) – Jan Dahlgaard/Peter Rasmussen</li>



<li><strong>Kleopatra S F </strong>(e. Readly Express) – Stefan Persson/Michael Lönborg</li>



<li><strong>Kandis C N </strong>(e. Wishing Stone) – Ken Ecce/Henrik F Pedersen (a)</li>



<li><strong>Kiwi Shadow </strong>(e. Broad Bahn) – Kasper Foget/Michael Lönborg</li>
</ol>



<p class="wp-block-paragraph"><strong>Fotnot: *</strong>förstapriset för hästar som är premiechansade.</p>



<p class="wp-block-paragraph">Det är inte bara tävlingar på Charlottenlund. Senare på kvällen är det auktion. Klockan 18.30 är första utrop och <a href="https://sulkysport.se/wp-content/uploads/2025/08/danskderbyauktion2025.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/08/danskderbyauktion2025.pdf" target="_blank" rel="noreferrer noopener">auktionskatalogen hittar ni här</a>.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 Fem semi-classique-löpningar bjuds det på <strong>Vincennes </strong>idag (första start kl. 13.23) och dessutom flera blågula inslag.</p>



<p class="wp-block-paragraph">I Prix de Moret-sur-Loing (€46.000) startar svenskfödda duon <strong>Queen of the Night</strong> (e. Trixton) och <strong>Perfect</strong> (e. Soutwind Frank) över 2.100 meter autostart. Den senare tränas av Elke Frinta och kommer närmast från seger i Prix de la Celle-Saint-Cloud (€41.000) på Enghien.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/perfectscoopdyga-617x333.jpg" alt="" class="wp-image-748077"/><figcaption class="wp-element-caption">Elke Frinta-tränade Perfect vinner för Paul-Philippe Ploquin. Foto Scoopdyga.com</figcaption></figure>



<p class="wp-block-paragraph">Vidare plockar Johan Untersteiner ut <strong>Toto Barosso </strong>(e. Ready Cash) i Prix de Neuilly (€75.000) över 2.850 meter och Franck Ouvrie tar hand om tömmarna. <strong>Maggiore</strong> (e. Googoo Gaagaa) startar i Prix de Cachan (€59.000) över 2.100 meter autostart och möter bland andra Maria Törnqvists <strong>Fighter Simoni</strong> (e. Orlando Vici) och Jörgen Westholm-tränade <strong>Garth Vader</strong> (e. Ken Warkentin).</p>



<p class="wp-block-paragraph">I Prix de Molay (€46.000) kommer en blågul duo ut. Björn Goops <strong>The Lion </strong>(e. Readly Express) och Erik Bondos <strong>Pure Steel</strong> (e. Bird Parker) i ett lopp över 2.100 meter autostart.</p>



<p class="wp-block-paragraph">Av semi-classique-löpningarna ska franska Stokriteriet – Criterium des Pouliches (€130.000) – nämnas i första hand och där favoritskapet delas mellan <strong>Mille Etoiles</strong> (e. Prodigious) och <strong>Magic Night </strong>(e. Helgafell), tränade av Nicolas Bazire respektive Philippe Allaire.</p>



<p class="wp-block-paragraph">Dagens begivenhet är <strong>Liza Josselyn </strong>(e. Ready Cash) och stoet imponerade stort i senaste starten och blir storfavorit till segern i Prix Gaston de Wazieres (€120.000) för fyraåriga ston över 2.700 meter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-08-30/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-08-30/" target="_blank" rel="noreferrer noopener">Startlistorna till Vincennes tävlingar hittar ni här.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 David Miller – en av USA:s främsta kuskar penningmässigt genom tiderna – gör sin sista säsong på Meadowlands och sedan flyttar han tillbaka till hemstaten Ohio.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/skarmavbild20230520kl.06.26.23-617x421.jpg" alt="" class="wp-image-446848"/><figcaption class="wp-element-caption">David Miller har vunnit 14.472 lopp i sin karriär. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">– Jag har pratat om att flytta hem de senaste fem åren. För två<br>år sedan köpte jag mark och mitt hus i Ohio är ungefär till två tredjedelar färdigt. De säger att jag kan flytta in i slutet av november, berättar David Miller, 60 år, för Harness Racing Update, och fortsätter:</p>



<p class="wp-block-paragraph">– I Ohio har jag i princip bara tre banor att tävla på och alla ligger inom räckhåll. Jag behöver inte flyga någonstans för att köra, eller köra sex timmar för att köra en häst. För min del blir det mycket enklare, att bara koncentrera mig på Scioto Downs, Miami Valley och Dayton Raceway.</p>



<p class="wp-block-paragraph">David Miller kan snart bli världens vinstrikast kusk genom tiderna. Hittills har karriären inbringat 295.967.128 dollar och det fattas bara drygt 3,9 miljoner dollar innan han når John Campbells 299.892.141 dollar.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Robert Skoglund-tränade <strong>Ängsrask </strong>(e. Bork Odin-Ängsrappa) och Ulf Ohlsson spetsvann ett försök till Norskt Kallblodskriterium på Bjerke igår. Från ledningen travade treåringen 1.28,6a/2.100 meter efter ha avrundat sista 500 meterna på 1.26,5. Förstapriset uppgick till 40.000 norska kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/angsraskjohannafrunckprivat-617x333.jpg" alt="" class="wp-image-724565"/><figcaption class="wp-element-caption">Ängsrask och skötaren Johanna Frunck. Foto Privat</figcaption></figure>



<p class="wp-block-paragraph">Det andra försöket gick till Kjetil Djöseland-tränade <strong>Grude Nils</strong> (e. Grisle Odin G.L.-Grude Jenta) och Åsbjörn Tengsareid på 1.29,1.</p>



<p class="wp-block-paragraph">Försök hölls också till det Norska Derbyt och <strong>Tangen Martin</strong> (e. Bork Odin-Tangen Mina) kom närmast från seger i Svenskt Kallblodsderby och vann från ledningen för Tom Erik Solberg på 1.25,9a/2.600 meter efter 1.21,1 sista halvvarvet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/9tangenmartin4-617x333.jpg" alt="" class="wp-image-753527"/><figcaption class="wp-element-caption">Tangen Martin och Tom Erik Solberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Från tät vann också <strong>Gigant Tider </strong>(e. Norheim Svenn-Glade Tider) för Magnus Teien Gundersen på 1.25,7.</p>



<p class="wp-block-paragraph">Jan-Olov Persson kunde också glädja sig åt en spetstriumf för <strong>Hulte Adam</strong> (e. Hulte Magnus-Hulte Saga) och Svein Ove Wassberg på 1.27,5.</p>



<p class="wp-block-paragraph">Varmbloden kvalade också till Kriteriet och <strong>Catchagaga Volo</strong> (e. Googoo Gaagaa-Catch A Volo) gjorde sitt jobb från spets på 1.15,6a/2.100 meter för Erlend Rennesvik efter ha avrundat sista 500 meterna på 1.11,4.</p>



<p class="wp-block-paragraph">Ledningen var också segermelodin för Magnus Teien Gundersen och <strong>Onyx B.R.</strong> (e. Maharajah-Metior Missy) på 1.14,2 efter 1.10,8 sista halvvarvet.</p>



<p class="wp-block-paragraph">Erlen Rennesvik och <strong>Iaintnoquitter </strong>(e. Quite Easy-Shanaia) tog hem det första försöket i Norskt Derby på 1.15,3a/2.600 meter. Därefter vann Magnus Teien Gundersen bakom <strong>Nadal B.R.</strong> (e. Googoo Gaagaa-Gaga B.R.) på 1.15,5.</p>



<p class="wp-block-paragraph">Därefter fortsatte Frode Hamre med en dubbel. <strong>Timestile R.</strong> (e. Readly Express-G. Fifty) och Tom Erik Solberg vann på 1.14,7 innan <strong>Tix </strong>(e. El Diablo B.R.-Princess Endurance) avrundade för Vidar Hop på 1.14,5 efter snabba 1.10,1 sista 500 meterna.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 Mohawk Raceway bjuder på topplopp i natt svensk tid och både Marcus Melander och Åke Svanstedt har chanser till stora slantar. <strong>Maryland </strong>(e. Chapter Seven) är tillbaka på tävlingsbanan efter tredjeplatsen i Hambletonian Stakes och går ut i Simcoe Stakes (C$158.125).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/maryland1392024deangillette-617x347.jpg" alt="" class="wp-image-634043"/><figcaption class="wp-element-caption">Marcus Melanders Maryland. Foto: Dean Gillette</figcaption></figure>



<p class="wp-block-paragraph"><strong>Simcoe Stakes</strong> (C$158.125)<br>Treåringar.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Maryland </strong>(e. Chapter Seven) – Dexter Dunn</li>



<li><strong>Wildturkey Hanover</strong> (e. Bar Hopping) – Philippe Hudon</li>



<li><strong>Pierre In Paris</strong> (e. Archangel) – Trevor Henry</li>



<li><strong>Fadeaway Hanover </strong>(e. Chapter Seven) – James MacDonald</li>



<li><strong>P L Spencer</strong> (e. Resolve) – Bob McClure</li>



<li><strong>Emoticon Legacy</strong> (e. Walner) – Louis-Philippe Roy</li>



<li><strong>Galen Erso </strong>(e. Green Manalishi) – Doug McNair</li>



<li><strong>Southwind Caspian</strong> (e. Walner) – Todd Ratchford</li>
</ol>



<p class="wp-block-paragraph">Stonas uppgörelse i Simcoe Stakes (C$159.725) har lockat tre svensktränade treåringar. Susanne Kerwood startar <strong>R Dutchess </strong>(e. Father Patrick), Marcus Melander plockar ut <strong>Margareta Hanover (</strong>e. Maharajah) och Nancy Takters bidrag är <strong>Highlandstarburst (</strong>e. Father Patrick).</p>



<p class="wp-block-paragraph"><strong>Simcoe Stakes</strong> (C$159.725)<br>Treåriga ston.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Lasting Dream </strong>(e. Cantab Hall) – Louis-Philippe Roy</li>



<li><strong>Supergirl Molly </strong>(e. Muscle Mass) – James MacDonald</li>



<li><strong>Frenchmoni Hanover</strong> (e. International Moni) – Billy Davis Jr.</li>



<li><strong>Medley Seelster </strong>(e. Wheeling N Dealin) – Jody Jamieson</li>



<li><strong>R Dutchess </strong>(e. Father Patrick) – Tim Tetrick</li>



<li><strong>Sprite Seelster</strong> (e. Green Manalishi) – Tyler Borth</li>



<li><strong>Highlandstarburst </strong>(e. Father Patrick) – Yannick Gingras</li>



<li><strong>Roxie Hart </strong>(e. Musical Rhythm) – Mario Baillargeon</li>



<li><strong>Margareta Hanover</strong> (e. Maharajah) – Dexter Dunn</li>



<li><strong>P L Sapphire </strong>(e. Father Patrick) – Bob McClure</li>



<li><strong>Green Glider </strong>(e. Green Manalishi) – Trevor Henry</li>
</ol>



<p class="wp-block-paragraph">Lördagens mest penningstinna löpning på Mohawk Raceway är finalen i Maple Leaf Trot (C$630.000) för äldre travare med fyra svensktränade travare och däribland Marcus Melanders försöksvinnare<strong> Aetos Kronos.</strong> Bold Eagle-sonen vann på den snabbaste tiden någonsin på kanadensisk mark, 1.08,2 över 1.609 meter.</p>



<p class="wp-block-paragraph">Marcus Melander startar också <strong>Periculum </strong>(e. Muscle Hill) och från Åke Svanstedts stall selas duon <strong>Call Me Goo</strong> (e. Googoo Gaagaa) och <strong>Up Your Deo</strong> (e. Walner) ut.</p>



<p class="wp-block-paragraph"><strong>Maple Leaf Trot</strong> (C$630.000)<br>Treåriga &#038; äldre travare.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Private Access </strong>(e. Muscle Hill) – Louis-Philippe Roy</li>



<li><strong>Call Me Goo</strong> (e. Googoo Gaagaa) – Tim Tetrick</li>



<li><strong>Aetos Kronos </strong>(e. Bold Eagle) – Dexter Dunn</li>



<li><strong>Periculum</strong> (e. Muscle Hill) – Scott Zeron</li>



<li><strong>Lexus Kody</strong> (e. Archangel) – Yannick Gingras</li>



<li><strong>Southwind Coors</strong> (e. Walner) – Jason Bartlett</li>



<li><strong>Gaines Hanover </strong>(e. Cantab Hall) – Bob McClure</li>



<li><strong>Chapercraz </strong>(e. Crazy Wow) – James MacDonald</li>



<li><strong>Hillexotic</strong> (e. Muscle Hill) – Jody Jamieson</li>



<li><strong>Up Your Deo</strong> (e. Walner) – Åke Svanstedt</li>



<li><strong>Logan Park</strong> (e. Archangel) – Doug McNair</li>
</ol>
