
<p class="has-drop-cap wp-block-paragraph">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 class="wp-block-paragraph">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 class="wp-block-paragraph">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 Mustard som blev först under 1.20 då han vann på 1.18,9a/3.100 meter.</p>



<p class="wp-block-paragraph">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 class="wp-block-paragraph">I uttagningsloppen till årets upplaga var Daniel Redén-tränade <strong>Epic Kronos</strong> (e. Muscle Hill) snabbast av de sex vinnarna när han tillsammans med Örjan Kihlström travade 1.12,0a/2.640 meter. Bara Calgary Games har travat snabbare i Derbyt eller Derbykval.</p>



<p class="wp-block-paragraph">– Jag har hela tiden vetat att det är en enormt bra häst. Tidigt som treåring gav han lite Francesco Zet-vibbar, men sedan började det spöka för honom, säger Daniel Redén om Epic Kronos i en intervju med Sulkysport.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/francesco-zet-vibbar/" target="_blank" rel="noreferrer noopener">Läs hela intervjun här!</a></p>



<h2 class="wp-block-heading">Snabbaste vinnarna i Svenskt Travderby</h2>



<p class="wp-block-paragraph"><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>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>2013 <strong>Mosaique Face</strong> (e. Classic Photo) – Lutfi Kolgjini – 1.12,4a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">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 class="wp-block-paragraph">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 class="wp-block-paragraph">Mattias Djuse tog sin första tränarseger i Derbystoet 2019 med <strong>Racing Brodda</strong> (e. Prodigious). Idag har han dubbla chanser med två finalister: <strong>Knickers Sisu</strong> (e.Southwind Frank) och <strong>Dial Square</strong> (e. Ready Cash).</p>



<p class="wp-block-paragraph">– Det är ju i de här sammanhangen vi tränar för att vara med i och det känns kul att ha med två deltagare i Derbystoet Att de dessutom ska köras av mina bröder gör det extra speciellt, konstaterar Mattias.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/dubbelt-djuse-i-derbystoet-bra-feeling/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Mattias här!</a></p>



<h2 class="wp-block-heading">Snabbaste vinnarna i Derbystoet</h2>



<p class="wp-block-paragraph"><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>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>2012 <strong>Red Red Red</strong> (e. Offshore Dream) – Fredrik Persson – 1.12,2a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3Spelmässigt står V75 på menyn på Jägersro idag och Sulkysports expert går hårt på två hästar i de största loppen – det blir nämligen spik i både Svenskt Travderby och Derbystoet på spelförslaget!</p>



<p class="wp-block-paragraph">Så här motiveras enkelstrecken:<br><em>”<strong>Fame And Glory</strong> (V75-7) är kullens kung så här långt och även om Epic Kronos svarade för en grym uppvisning i sitt kval, så tvekar vi inte när vi fortsatt har förtroende för Timo Nurmos träning med Björn Goop vid tömmarna.<br>Bland stona i Derbystoet är det öppet. ”En eller många” var frågan när vi konstruerade systemet och till slut tog vi ställning för <strong>Knickers Sisu</strong> (V75-3) som verkligen övertygade i sin uttagning. Lite tuffare nu då hon troligen inte når ledningen, men hon tål att göra jobb också.”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-jagersro-1-september/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara på V75.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-09-01_7_6">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-09-01_7_6">Sulkysport V75 UNIK – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph">Förutom på Jägersro travas det på ytterligare en svensk bana. Dagen inleds nämligen med breddlopp i <strong>Vaggeryd</strong> (start 11.10).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Nästa lördag avgörs den 90:e upplagan av heatloppet Campionato Europeo (€154.000) i Cesena och där ska <strong>Click Bait </strong>(e. Cantab Hall) debutera för sin nya tränare Alessandro Gocciadoro. Av fältets tolv travare kommer fem från Gocciadoro-stallet och förutom Click Bait handlar det om <strong>Dali Prav</strong>, <strong>Denver Gio</strong>, <strong>Diamond Truppo </strong>och <strong>Heart of Steel</strong>.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/07/clickbaitpld240713adamstromstalltz-scaled.jpg" alt="" class="wp-image-609152"/><figcaption class="wp-element-caption">Click Bait debuterar i ny regi nästa vecka i Campionato Europeo. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Följande hästar ställer upp i Campionato Europeo:</p>



<ul class="wp-block-list">
<li><strong>Capital Mail</strong> (e. Nad al Sheba)</li>



<li><strong>Click Bait </strong>(e. Cantab Hall)</li>



<li><strong>Denver Gio</strong> (e. Southwind Frank)</li>



<li><strong>Akela Pal Ferm </strong>(e. Maharajah)</li>



<li><strong>Chance Ek</strong> (e. Nad al Sheba)</li>



<li><strong>Diamond Truppo</strong> (e. Varenne)</li>



<li><strong>Dali Prav</strong> (e. Donato Hanover)</li>



<li><strong>Amon You Sm</strong> (e. Love You)</li>



<li><strong>Vesna </strong>(e. Libeccio Grif)</li>



<li><strong>Zefiro d’Ete</strong> (e. Mago d’Amore)</li>



<li><strong>Callisto </strong>(e. Nad al Sheba)</li>



<li><strong>Heart of Steel</strong> (e. Cantab Hall)</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">5 Överlägset bästa snittet på Ventes de Yearlings Sélectionnés i Deauville hade framlidne <strong>Ready Cash</strong> med 201.875 euro och den billigaste av hans åtta avkommor gick för 95.000 euro och den dyraste –<strong> Nodessa Josselyn</strong> (u. Belina Josselyn) gick för rekordhöga 740.000 euro. Ready Cash hade också den näst dyraste ettåringen och Courant Inc. Betalade 190.000 euro för <strong>New Winner</strong> (u. Hovely Winner).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/06/readycash12-617x288.jpg" alt="" class="wp-image-25774"/><figcaption class="wp-element-caption">Ready Cash. Foto Mia Törnberg/Sulkysport
</figcaption></figure>



<p class="wp-block-paragraph">Av nykomlingarna hade Ready Cash-sonen <strong>Italiano Vero</strong> bäst snitt och landade på 52.944 euro och av hans ettåringar kostade <strong>Novello</strong> (u. Baaria) mest och det var agenten Jack de Jong som hade högsta budet på 120.000 euro.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/12/prixourasiitalianovero-617x389.jpg" alt="" class="wp-image-124266"/><figcaption class="wp-element-caption">Italiano Vero. Foto: Gerard Forni</figcaption></figure>



<h2 class="wp-block-heading">Tio bästa snitten på Arqana Trot</h2>



<p class="wp-block-paragraph"><strong>Avelshingst – Antal – Totalt (euro) – Snitt (euro)</strong></p>



<ol class="wp-block-list">
<li><strong>Ready Cash</strong> – 8 – €1.615.000 – €201.875</li>



<li><strong>Follow You</strong> – 4 – €356.000 – €89.000</li>



<li><strong>Face Time Bourbon</strong> – 16 – €1.151.000 – €71.938</li>



<li><strong>Love You</strong> – 11 – €589.000 – €53.545</li>



<li><strong>Italiano Vero</strong> – 18 – €953.000 – €52.944</li>



<li><strong>Hohneck</strong> – 13 – €649.000 – €49.923</li>



<li><strong>Carat Williams</strong> – 8 – €357.000 – €44.625</li>



<li><strong>Bird Parker</strong> – 6 – €230.000 – €38.333</li>



<li><strong>Fabulous Wood</strong> – 5 – €175.000 – €35.000</li>



<li><strong>Royal Dream</strong> – 4 – €138.000 – €34.500</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6 Rena rama krypkasinot var det i finalen i Derby der Vierjarighen (€30.800) på Victoria Park i Wolwega igår sedan storfavoriten Novato kom till ledningen efter 500 meter och sedan fått bestämma första kilometern efter 1.18,5.</p>



<p class="wp-block-paragraph">Micha Brouwer släppte välvilligt täten med <strong>Niagara River</strong> (e. Orlando Vici-Hopewell River) och när Jeffrey Mieras lade in överväxeln 800 kvar blev det ordentlig temposkärpning. Ledande Novato hade dock inte sin bästa dag och kunde inte stå emot stoet Niagara River sista biten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/skarmavbild20240831kl.21.40.39-617x408.jpg" alt="" class="wp-image-628626"/><figcaption class="wp-element-caption">Utvändiga Niagara River är på väg att koppla greppet på Novato. </figcaption></figure>



<p class="wp-block-paragraph">Vinnartiden skrevs till 1.14,6a/2.100 meter och samma tid noterade Novato (e. Maharajah) som tvåa. Tidigare i år Niagara River vunnit Criterium der Vierjarigen (€11.990) och ifjol vann hon stoavdelningarna i såväl Sweepstakes (€19.800) som Fokkers Trofee (€9.600).</p>



<p class="wp-block-paragraph">Niagara River är första avkomman undan <strong>Hopewell River</strong> (e. Quite Easy), vilken tog sitt rekord 1.20,6 i ett kvallopp, och är undan <strong>Twilight River</strong> (e. Super Arnie), 1.15,1/€13.375.</p>



<p class="wp-block-paragraph">I Wolwega hölls också två försök i Breeders Course (€11.000) för tvååringar. I hingstarnas och valackernas uppgörelse debutvann<strong> Pronto</strong> (e. Robert Bi-Anabaa Blue) för Jim Veldman på 1.14.0a/1.609 meter, medan <strong>Gourmet d’Arc</strong> (e. Six Pack-Vogue di Poggio) toppade för Micha Brouwer på 1.15,1. För Gourmet d’Arc var det också första starten i karriären.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Alessandro Gocciadoro vann både hingstarnas och stonas uppgörelse i Gran Premio Citta di Follonica (€66.000) för fyraåringar igår på Ippodromo Dei Pini.</p>



<p class="wp-block-paragraph"><strong>East Asia</strong> (e. Ready Cash-Elvezia) spetsvann överlägset och landade på 1.11,4a/2.200 meter, medan måltvåan Eloida (e. Napoleon Bar) kom hem på 1.12,5 och trean Elise Ana (e. Maharajah) travade tiondelen långsammare.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/eastasia-350x168.png" alt="" class="wp-image-619337"/><figcaption class="wp-element-caption">East Asia.</figcaption></figure>



<p class="wp-block-paragraph">East Asia kom närmast från seger i Campionato Femminile (€66.000). East Asia är undan ostartade <strong>Elvezia </strong>(e. Pine Chip), vilken ingår i samma syskonskara som toppstoet <strong>Prussia</strong> (e. Ken Warkentin), 1.10,8/€478.555, med segrar bland annat i Gran Premio d’Europa Filly och Grupp I-löpningarna Gran Premio Gaetano Turilli och Gran Premio Nazioni.</p>



<p class="wp-block-paragraph">Vinst blev det också för <strong>Executiv Ek</strong> (e. Face Time Bourbon-Nike Ek) och Alessandro Gocciadoro på 1.12,2a/2.200 meter. Duon tog sig fram i dödens varvet kvar och greppet kopplades vid utgången av sista sväng.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/executivek-617x411.jpg" alt="" class="wp-image-413984"/><figcaption class="wp-element-caption">Executiv Ek.</figcaption></figure>



<p class="wp-block-paragraph">Bakom honom följde Encierro (e. Tobin Kronos) och Edy Girifalco Gio (e. Victor Gio) på 1.12,3 respektive 1.12,4.</p>



<p class="wp-block-paragraph">Tidigare i år har Executiv Ek vunnit Gran Premio Unione Europa (€209.000), Gran Premio Regione Campania (€66.000) i Neapel och även räknat hem Grupp III-klassade Prix d’Orthez (€90.000) på Vincennes.</p>



<p class="wp-block-paragraph">Modern <strong>Nike Ek</strong> (e. Varenne), 1.13,2/€42.392, har sedan tidigare lämnat två Grupp I-vinnare i form av <strong>Always Ek</strong> (e. Filipp Roc), 1.08,6*/€534.336, och<strong> Vanesia Ek</strong> (e. Exploit Caf), 1.10,7/€436.144,.</p>



<p class="wp-block-paragraph">I Follonica tog också svenskfödde <strong>Faen Troot </strong>(e. Readly Express-Giant Diablo) och Roberto Vecchione hem Prix Estate d’Alfa (€4.510) på 1.12,5a/1.600 meter.</p>
