
<p class="has-drop-cap">1<strong>Etonnant, Hohneck</strong> och <strong>Horsy Dream</strong>. Tre år i rad har franska hästar vunnit Elitloppet på Solvalla och i år mönstrar landet fem deltagare för en fjärde raka triumf. Mot detta ställer Sverige i första hand Daniel och Daniel. Två gånger om dessutom.</p>



<p>Redén har fjolårets fyra <strong>Francesco Zet</strong> (e. Father Patrick) och sin senaste svenske vinnare <strong>Don Fanucci Zet</strong> (e. Hard Livin).<br>– Jag kan inte ha honom i bättre slag än vad han är nu. Han är finare nu än tidigare. Mjukare, springer lite rakare och mer reglerbar. Förra året var han inte riktigt tillfreds, bland annat saknade han lopp i kroppen och han lite för stum på alla sätt och vis, säger Daniel Redén om Francesco Zet.</p>



<p>Wäjerstens duo är fjolårstvåan och Årets Häst i Sverige 2025 <strong>Borups Victory</strong> (e. Googoo Gaagaa) och <strong>Mellby Jinx</strong> (e. Ready Cash).<br>– Jag tycker att han känns precis lika bra som förra året, säger Wäjersten om Borups Victory.</p>



<p><a href="https://sulkysport.se/e-tidning-allt-infor-elitloppshelgen/" target="_blank" rel="noreferrer noopener">Du har väl inte missat Sulkysports tidning inför Elitloppet?</a></p>



<p>26 franskfödda hästar har vunnit Elitloppet. Det gör landet till det mest framgångsrika i loppets historia. Bakom skuggar Sverige med 19 vinnare och USA står på 18.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/05/25v75.pdf">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/7doubledeceiver2-617x333.jpg" alt="" class="wp-image-722994"/><figcaption class="wp-element-caption">Örjan Kihlström värmde upp med att vinna försök och final i Sweden Cup bakom Daniel Redén-tränade Double Deceiver. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Stig H Johansson är störst i Elitloppshistorien – både som tränare och kusk. Legendaren har räknat in fem tränarsegrar och han körde själv alla till vinst. Som kusk kompletterade han med Stig Engberg-tränade <strong>Napoletano</strong>.</p>



<p>Av eftermiddagens kuskar i Elitloppet vet fyra kuskar redan hur det känns att vinna Elitloppet. Fransmännen Anthony Barrier (<strong>Etonnant</strong>) och Romain Derieux (<strong>Dijon</strong>) samt italienaren Gabriele Gelormini (<strong>Hohneck</strong>) har gjort det en gång vardera. Örjan Kihlström har vunnit Elitloppet fyra gånger!</p>



<p>Därmed delar Kihlström andraplatsen i kuskligan med tyske legendaren Johannes Frömming som vann lika många gånger.<br>Att det inte är någon fel på Kihlströms kuskform inför dagen visade han med eftertryck på Solvalla under lördagen. Han inledde med att vinna sina fem första lopp, samtliga med en häst tränad av Daniel Redén!</p>



<p><strong>Körsvenner med minst tre vinnare i Elitloppet:</strong><br><em>Tränare – Antal segrar – Vinnarhästar</em></p>



<ul class="wp-block-list">
<li><strong>Stig H Johansson</strong> – 6 – The Onion 1984, Utah Bulwark 1987, Napoletano 1989, Peace Corps 1991, Gum Ball 1997, Victory Tilly 2000</li>



<li><strong>Johannes Frömmning</strong> – 4 – Eidelstedter 1962, Elma 1965, Eileen Eden 1968, 1970</li>



<li><strong>Örjan Kihlström</strong> – 4 – From Above 2003, Magic Tonight 2015, Nuncio 2016, Don Fanucci Zet 2021</li>



<li><strong>Björn Goop</strong> – 3 – Conny Nobell 2006, Timoko 2014, 2017</li>



<li><strong>Leopold Verroken</strong> – 3 – Dimitria 1976, Eleazar 1977, Jorky 1981</li>
</ul>



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



<p class="has-drop-cap">3Elitloppet i all ära, det bjuds fler miljonlopp på <strong>Solvalla </strong>(första start 12.45) idag. Tre andra lopp bjuder en miljon kronor i förstapris och det handlar om det båda Breeders Course-finalerna för treåringar och kallblodens Elitkamp.</p>



<p>Breeders Course ingår för första gången även i premiechansen och de svenskfödda finalisterna tävlar om 1,5 miljoner i förstapris. Där dyker bland annat Årets tvååring i Sverige 2024 upp. Per Nordströms <strong>Eyeofthetiger</strong> (e. Django Riff) travade svenska rekordet 1.12,0a/1.640 meter när han vann försök till Svensk Uppfödningslöpning, men galopperade i finalen.<br>– Eyeofthetiger är stor som ett hus (1,74) och kommer att vara utrustad med en högre vagn, säger Per Nordström som, precis som vid svenska rekordet anlitar Stefan Persson som kusk bakom Eyeofthetiger, medan han själv kör <strong>Wise Guy</strong> (e. Face Time Bourbon).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/08/perssonjankolllopp-617x527.jpg" alt="" class="wp-image-105317"/><figcaption class="wp-element-caption">Jan-Olov Persson tittade långt efter skylten som visade sluttiden 1.17,9 för Järvsöfaks i Gävle 2005. Foto Stalltz.se</figcaption></figure>



<p>På kallblodssidan fyller Järvsöfaks fantastiska världsrekord 1.17,9a/1.640 meter från Gävle den 12 juli 2005 i år 20 år och det finns förutsättningar att det går undan i årets upplaga av Elitkampen. Löpningsrekordet noterades av finske <strong>Vitter</strong> (e. Viesker) för nio år sedan, 1.18,5a, medan både <strong>Odd Herakles</strong> (e. Moe Odin) och <strong>Tangen Bork</strong> (e. Bork Odin) vunnit på 1.18,6. Den sistnämnde finns på plats för att försvara sin titel idag.</p>



<p><strong>Tidsintervall för vinnarna i Elitkampen:</strong></p>



<ul class="wp-block-list">
<li>Under 1.19,0: Fem vinnare</li>



<li>1.19,0-1.19,9: Nio Vinnare</li>



<li>1.20,0-1.20,9: Tio vinnare</li>



<li>1.21,0-1.21,9: Sju vinnare</li>



<li>1.22,0-: Åtta vinnare</li>
</ul>



<p>Elitloppsdagen innebär även V75-spel och Sulkysports expert har analyserat omgången noga. Det har landat i två singelstreck signerade Daniel Redén och Örjan Kihlström.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-sondag-duon-bakom-spikarna/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till V75.</a></p>



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



<p class="has-drop-cap">4 En svenskfödd vinnare sågs på Enghien igår. Jean-Michel Bazire vann bakom <strong>Killiam Fromentro </strong>(e. Villiam-Caryatide) och duon tog hem Prix du Rhone (€71.000) på 1.11,8a/2.150 meter.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/skarmavbild20250524kl.16.48.00-350x208.png" alt="" class="wp-image-723012"/><figcaption class="wp-element-caption">Killiam Fromentro vinner för Jean-Michel Bazire.</figcaption></figure>



<p>Första kurvan inleddes ute i tredjespår, täten övertogs 1.500 kvar för att släppa kort efteråt och sedan återta kommandot kilometern före mål. På upploppet gick den femårige hingsten in i några längders ledning och kunde vinna avstannande.</p>



<p>Nicolas Bazire tränar och segern var värd 31.950 euro. Tidigare i år har också Killiam Fromentro vunnit Prix d’Argenton-sur-Creuse (€46.000) på Vincennes.</p>



<p>På Enghien kunde också Johan Untersteiner räkna in en andraplats för Toto Barosso (e. Ready Cash) på 1.12,7. Vann Prix de l’Obelisque (€75.000) gjorde <strong>Hubble du Vivier</strong> (e. Vulcain du Vivier-Minnie du Vivier) och Jean-Michel Bazire på 1.12,5a/2.150 meter.</p>



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



<p class="has-drop-cap">5 På Harrah’s Philadelphia i Chester blir det ett svenskmöte i Maxie Lee Memorial ($100.000) över en engelsk mil. Ifjol vann Marcus Melander-tränade <strong>Venerate </strong>(e. Love You) – idag avelshingst på Broline – på löpningsrekordet 1.08,5/1.609 meter.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/05/wb051025r8aetoskronos.jpg" alt="" class="wp-image-717777"/><figcaption class="wp-element-caption">Aetos Kronos vid en tidigare seger på Meadowlands för Dexter Dunn. Foto: Lisa Photo</figcaption></figure>



<p>I årets upplaga selar han ut svenskfödde <strong>Aetos Kronos </strong>(e. Bold Eagle), vilken ställs mot en annan blågul travare; <strong>Antognoni</strong> (e. Father Patrick). Aetos Kronos tog sig till final i Elitloppet 2021 efter en fjärdeplats i försöket, men slutade sist i finalen.</p>



<p><strong>Maxie Lee Memorial</strong> ($100.000)<br>Äldre travare.<br><em>1.609 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Antognoni</strong> (e. Father Patrick) – Yannick Gingras</li>



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



<li><strong>Amigo Volo</strong> (e. Father Patrick) – Todd McCarthy</li>



<li><strong>Sir Pionocchio</strong> (e. Met’s Hall) – Jason Bartlett</li>



<li><strong>Benjamin Hanover</strong> (e. Sebastian K.) – Tim Tetrick</li>



<li><strong>College Tuition</strong> (e. Donato Hanover) – Andrew McCarthy</li>



<li><strong>Usain Hanover</strong> (e. Bar Hopping) – David Miller</li>



<li><strong>Secret Agent Man</strong> (e. Chapter Seven) – Andy Miller</li>
</ol>



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



<p class="has-drop-cap">6 <strong>Argentan</strong> (kl 11.03) öppnar upp söndagens tävlingar i Frankrike och dit åker Markus B Svedbergs och Srf Stable-ägda fyraåring<strong> Lale</strong> (e. Bold Eagle) och är på jakt efter sin andra raka seger. Mathieu Mottier sitter i sulkyn i Prix Franck Anne (€21.000) över 2.875 meter och det lockas med ett förstapris på 9.450 euro.</p>



<p>På samma bana plockar Jarmo Niskanen ut <strong>Katitzi</strong> (e. Earl Simon) och Alexandre Bodin sköter tömmarna i Prix Cave Henri IV (€24.000) för femåriga ston över 2.875 meter och där vinnaren belönas med 10.800 euro.</p>



<p>Jarmo Niskanen har också <strong>King Elvis </strong>(e. Bold Eagle) till start i lärlingsloppet Prix Roquepine (€21.000) Chateaubriant över 3.000 meter.</p>



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



<p class="has-drop-cap">7 Alla blickar vänds inte bara mot Solvalla idag utan det tävlas också på andra banor runt om i Europa, men med betydligt mindre prissummor. Jörgen Sjunnesson åker till <strong>Berlin</strong> (kl 13.00) och har tre uppsittningar på Mariendorf.</p>



<p>Bakom <strong>His Higness S </strong>(e. Credit Winner) jagar Sjunnesson tredje raka segern i Roquepine-Rennen (€2.250), <strong>Out For Fame A.M.</strong> (e. Manofmanymissions) i Commander Crowe-Rennen (€2.500) och <strong>Marjan</strong> (e. Pastor Stephen) i Timoko-Rennen (€1.500).</p>



<p>Jörgen Sjunnesson visade kuskform i fredags när han tog hem danska Sprintermästaren med <a href="https://sulkysport.se/skrallvinst-av-sjunnesson/" data-type="link" data-id="https://sulkysport.se/skrallvinst-av-sjunnesson/" target="_blank" rel="noreferrer noopener">Kalles Krisbe Notz</a> i Odense.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Ska bryta franska sviten i Elitloppet
Daniel eller Daniel ska bryta franska Elitloppssviten. Kihlström jagar Stig H. Snabbaste kallbloden på Solvalla. Elitloppsfinalist i amerikanskt storlopp. Svenska framgångar på Enghien.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
