
<p class="has-drop-cap">11.30,9 travade <strong>Ibrahim Pascha</strong> och Sophus Sörensen när han fullbordade tidernas första ”Triple Crown” i Sverige och plockade hem första upplagan av Svenskt Travderby 1928. Ibrahim Pascha hade åren före segrat i både Svensk Uppfödningslöpning och Svenskt Travkriterium.</p>



<p>2021 satte <strong>Calgary Games</strong> (e. Readly Express) när han hade uppvisning och blev förste svenske Derbyvinnare att trava under 1.12. Klockan visade 1.11,7a/2.640 meter.</p>



<p>Först under 1.30 var Sixten Lungren-tränade <strong>Lorry</strong>, som 1933 travade 1.29,6. Sedan dröjde det ända till 1980 innan nästa drömgräns passerades. Sören Nordin var mannen bakom <strong>Mustard</strong> som blev först under 1.20 då han vann på 1.18,9a/3.100 meter.<br>13 år senare var superstoet <strong>Ina Scot</strong> (e. Allen Hanover) först att spränga 1.15-gränsen när hon tillsammans med Kjell P Dahlström slog hingstarna på 1.14,9/2.640 meter. Då var alltså distansen halvvarvet kortare än i flertalet av Derbyts upplagor. 1983 kortades nämligen sträckan för travets blå band till 2.640 meter.</p>



<p>Hur snabbt kommer det att travas i eftermiddag på Jägersro när en ny Derbyvinnare ska koras?</p>



<p><a href="https://sulkysport.se/vem-ar-esset-i-leken/" target="_blank" rel="noreferrer noopener">––> Läs mer om alla deltagare i Svenskt Travderby här!</a></p>



<p><strong>Snabbaste vinnarna i Svenskt Travderby</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2021 <strong>Calgary Games</strong> (e. Realdy Express) – Jorma Kontio (Timo Nurmos) – 1.11,7a</li>



<li>2025 <strong>Dream Mine</strong> (e. Maharajah) – Mats E Djuse (Jörgen Westholm) – 1.11,9a</li>



<li>2018 <strong>Who’s Who</strong> (e. Maharajah) – Örjan Kihlström (Pasi Aikio) – 1.12,0a</li>



<li>2022 <strong>Francesco Zet</strong> (e. Dather Patrick) – Örjan Kihlström (Daniel Redén) – 1.12,0a</li>



<li>2023 <strong>Joviality</strong> (e. Chapter Seven) – Erik Adielsson (Sabine Kagebrandt) – 1.12,1a</li>



<li>2014 <strong>Poochai</strong> (e. Make It Happen) – Örjan Kihlström (Svante Båth) – 1.12,3a</li>



<li>2017 <strong>Cyber Lane</strong> (e. Raja Mirchi) – Johan Untersteiner – 1.12,3a</li>



<li>2024 <strong>Fame And Glory</strong> (e. Tactical Landing) – Björn Goop (Timo Nurmos) – 1.12,3a</li>



<li>2013 <strong>Mosaique Face</strong> (e. Classic Photo) – Lutfi Kolgjini – 1.12,4a</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/bonseegarde-617x473.jpg" alt="" class="wp-image-890812"/><figcaption class="wp-element-caption">Bonsse Garde vinner för Carl Johan Jepson. Foto: Stefan Olsson/Cavok</figcaption></figure>



<p class="has-drop-cap">21991 fick stona en egen uppgörelse under Derbydagen på Jägersro när Derbystoet gjorde entré. Till skillnad mot huvudlöpningens långa distans tävlar stona över medeldistans och Rainer Ström-tränade <strong>Charm Patricia</strong> (e. Keystone Patriot) och Stefan Erlandsson vann premiärupplagan på 1.15,7a/2.140 meter.</p>



<p>30 år senare skrevs segertiden till löpningsrekordet 1,11,5 när Daniel Redéns <strong>Honey Mearas</strong> (e. Readly Express) triumferade tillsammans med Örjan Kihlström.</p>



<p><a href="https://sulkysport.se/allt-om-hastarna-i-derbystoet-2/" target="_blank" rel="noreferrer noopener">––> Läs mer om alla deltagare i Derbystoet här!</a></p>



<p><strong>Snabbaste vinnarna i Derbystoet</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2021 <strong>Honey Mearas</strong> (e. Readly Express) – Örjan Kihlström (Daniel Redén) – 1.11,5a</li>



<li>2017 <strong>Cash Crowe</strong> (e. Ready Cash) – Johnny Takter (Petri Puro) – 1.11,6a</li>



<li>2022<strong> Lara Boko</strong> (e. Djali Boko) – Mika Forss (Timo Nurmos) – 1.11,9a</li>



<li>2024 <strong>Daim Brodda</strong> (e. readly Express) – Eirik Höitomt (Thor Borg) – 1.11,9a</li>



<li>2018 <strong>Run Chica Run</strong> (e. Scarlet Knight) – Peter Untersteiner – 1.12,0a</li>



<li>2019 <strong>Racing Brodda</strong> (e. Prodigious) – Rikard N Skoglund (Mattias Djuse) – 1.12,1a</li>



<li>2023 <strong>Global Dancer</strong> (e. Carat Williams) – Carl Johan Jepson (Fredrik Wallin) – 1.12,1a</li>



<li>2025 <strong>S.G.Empress</strong> (e. Readly Express) – Rikard N Skoglund (Roger Walmann) – 1.12,1a</li>



<li>2012 <strong>Red Red Red</strong> (e. Offshore Dream) – Fredrik Persson – 1.12,2a</li>
</ul>



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



<p class="has-drop-cap">3Amatörernas Elitlopp – så har K.G. Bertmarks Minne kallats. På Derbydagen och på V85-kupongen är det dags för årets upplaga, dit elva amatörkuskar tagit sig via uttagningslopp på sex banor.</p>



<p>K.G. Bertmarks Minne kördes för första gången på Jägersro 1988 för att hedra Skånska Travsällskapets mångårige ordförande.</p>



<p>Nu återstår tio ekipage efter att <strong>Due Due</strong> (e. Raja Mirchi) fått strykas. Håkan B Johansson och Hanna Lähdekorpi har lyckats bäst i loppets historia med tre vinter vardera, men ingen av dem finns med i årets final. Där kommer nämligen en ny vinnare att koras. Ingen av deltagarna har vunnit K.G. Bertmarks Minne tidigare.</p>



<p>På avdelningen hyllningar av gamla hjältar…Bo William Takter – mannen bakom Derbyvinnaren 1983 <strong>Micko Fripe</strong> (e. Micko Tilly) bland mycket annat – hedras i stayerloppet Bo W Takter Tribute över tre varv. En av de senaste hemmavinnarna i travets blå band har också ett eget lopp – Mats Rånlunds vinnare i skyfallet 1995 <strong>Good As Gold</strong> (e. Sugarcane Hanover).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/jormakontio-617x333.jpg" alt="" class="wp-image-159800"/><figcaption class="wp-element-caption">Jorma Kontio. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4Efter elva tävlingsdagar är det dags för att sätta punkt för sommarbanan Lindesberg. Det sker med en breddloppsdag som inleds under förmiddagen (första start 11.10).</p>



<p>Sju gånger har Jorma Kontio blivit champion på Fornaboda och idag räknar han in en åttonde titel. Breddlopp gör att Jorma, som tävlade i Italien både i fredags och igår, inte finns med i startlistorna, men han har skaffat sig en ointaglig ledning efter att ha vunnit nio lopp under säsongen.<br>Jorma Kontio har sedan tidigare 46 svenska banchampionat.</p>



<p>Det tävlas även på Dannero (start 12.10), där Ove A Lindqvist och Ann-Catrin Frisk luftar Frensch Kronos (e. Face Time Bourbon) från spår åtta i snabbloppet över medeldistans. Sex miljonärer och två ”nästanmiljonärer” finns bland motståndarna.</p>



<p>Här är startlistorna till söndagens tävlingar.</p>



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



<p class="has-drop-cap">5 Penningstinna finaler bjuds det på i Pennsylvania Sire Stakes ($300.000) för treåringar idag i Chester och både Åke Svanstedt och Nancy Takter har hästar till start.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/highlanddestinysalonick-617x411.jpg" alt="" class="wp-image-852626"/><figcaption class="wp-element-caption">Highland Destiny och Scott Zeron vid en tidigare seger. Foto: Curtis Salonick</figcaption></figure>



<p>Nancy Takter har kvalat in <strong>Highland Destiny </strong>(e. Greenshoe) till final och Scott Zeron tar hand om tömmarna. Fyra segrar har det blivit hittills i år på elva starter.</p>



<p>I stonas final plockar Åke Svanstedt ut <strong>Maya Patel Hanover </strong>(e. Captain Corey) och bland motståndarna finns svenskfödda <strong>Frattina Diablo</strong> (e. Captain Corey), vilken tränas av Tony Alagna.</p>



<p><strong>Pennsylvania Sire Stakes</strong> ($300.000)<br>Treåriga ston.<br><em>1.609 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Carve </strong>(e. Captain Corey) – Andrew McCarthy</li>



<li><strong>Maya Patel Hanover</strong> (e. Captain Corey) – Åke Svanstedt</li>



<li><strong>Atlantic Summer</strong> (e. Captain Corey) – Ronnie Wrenn Jr.</li>



<li><strong>Shimmering Hanover</strong> (e. Captain Corey) – James MacDonald</li>



<li><strong>Shemightbetheone</strong> (e. Captain Corey) – Matt Kakaley</li>



<li><strong>Little Road </strong>(e. Fordham Road) – Brady Brown</li>



<li><strong>Ginger Tree Lex</strong> (e. Bar Hopping) – Todd McCarthy</li>



<li><strong>Frattina Diablo</strong> (e. Captain Corey) – Scott Zeron</li>
</ol>



<p><strong>Pennsylvania Sire Stakes</strong> ($300.000)<br>Treåriga hingstar/valacker.<br><em>1.609 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Fineline Hanover </strong>(e. Captain Corey) – Todd McCarthy</li>



<li><strong>Hamlet Hall</strong> (e. Cantab Hall) – Mike Wilder</li>



<li><strong>Dilly Hanover</strong> (e. International Moni) – Mark Herschberger</li>



<li><strong>Highland Destiny</strong> (e. Greenshoe) – Scott Zeron</li>



<li><strong>Geologic </strong>(e. Captain Corey) – Yannick Gingras</li>



<li><strong>Captain Vodka</strong> (e. Captain Corey) – Robert Baggit Jr.</li>



<li><strong>Oversear </strong>(e. International Moni) – Charlie Norris</li>



<li><strong>Minoan</strong> (e. Bar Hopping) – Andrew McCarthy</li>
</ol>



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



<p class="has-drop-cap">6 Det är inte bara i Sverige som det bjuds på Derby. I Baden avgörs Stoderbyt (€7.000) i Österrike för fyraåringar och sex ston tävlar om ett förstapris på 3.500 euro över distansen 2.100 meter, autostart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/ivanavenus-617x411.jpg" alt="" class="wp-image-864199"/><figcaption class="wp-element-caption">Ivana Venus. Foto: Krieau</figcaption></figure>



<p><strong>Ivana Venus</strong> (e. Explosive Matter) har tidigare i år vunnit både Derby-Versuchs-Rennen (€10.000) och Traber S:t Leger (€10.000) plus att hon slutade tvåa i det öppna Derbyt i Österrike.</p>



<p><strong>Österrikiskt Stoderby</strong> (€7.000)<br>Fyraåriga ston.<br>2.100 meter, autostart.</p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Melody’s Fabula</strong> (e. Fabulous Wood) – Gerhard Mayr</li>



<li><strong>Ivana Venus</strong> (e. Explosive Matter) – Christoph Fischer</li>



<li><strong>Merci Sherie</strong> (e. The Bank) – Hubert Brandstätter</li>



<li><strong>Darling Venus</strong> (e. Baltimore As) – Gregor Krenmayr</li>



<li><strong>Marbella Venus</strong> (e. Dreamboy AS) – Christoph Schwarz</li>



<li><strong>Mus Musculus </strong>(e. Light Kronos) – Thomas Pribil</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/2e32f4f818b276a91eb27bec93cb8efc-617x411.jpeg" alt="" class="wp-image-894543"/><figcaption class="wp-element-caption">Celebration kostade mest på auktion i Finland igår. Foto: Jokimaan Varsahuutokauppa</figcaption></figure>



<p class="has-drop-cap">7 En dotter till <strong>Readly Express</strong> betingades det högsta priset på auktionen Jokimaan Varsahuutokauppa. 32.500 euro betalades för <strong>Celebration</strong> och bakom köpet stod Journey Stable.</p>



<p>Modern <strong>Arctic Madonna</strong> (e. Express It), 1.13,8/€21.222, har tidigare lämnat <strong>Where’s the Party</strong> (e. Bar Hopping), 1.13,0/€82.700, och <strong>Crazy For You</strong> (e. Love You), 1.13,6ak/€31.140.</p>



<p>För egen del ingår hon helsyster med topptravaren <strong>Express Duo</strong>, 1.10,8/€662.951. Medelpriset på auktionen blev 6.160 euro och medianen 4.000 euro.</p>



<p><a href="https://www.travera.nu/hybridauktion/jokimaan-varsahuutokauppa-yearling-sale-finland/" data-type="link" data-id="https://www.travera.nu/hybridauktion/jokimaan-varsahuutokauppa-yearling-sale-finland/" target="_blank" rel="noreferrer noopener">Samtliga resultat från auktionen hittar du här.</a></p>
