
<p class="has-drop-cap wp-block-paragraph">1Tolv fyraåriga hingstar och valacker gör upp om 600.000 kronor i förstapris i Prix Readly Express när Solvalla (första start 18.30) bjuder på topptävlingar ikväll – och visst kan deltagarna känna lite press på sig inför uppgiften. Eller få drömmar om en än ljusare framtid. Segerlistan i loppets korta historia innehåller nämligen enbart storstjärnor.</p>



<p class="wp-block-paragraph">Eller vad sägs om vad dessa vinnare följde upp med efter triumfen i Prix Readly Express:</p>



<ul class="wp-block-list">
<li>2019 <strong>Attraversiamo</strong> (e. Kiss Francais), 10.088.500 kr, vann Derbyt och slutade tvåa i Elitloppet.</li>



<li>2020<strong> Don Fanucci Zet</strong> (e. Hard Livin), 14.5630.718 kr, vann Sprintermästaren, Elitloppet, Norrbottens Stora Pris och Hugo Åbergs Memorial, samt slutade tvåa i Derbyt.</li>



<li>2021 <strong>San Moteur</strong> (e. Panne de Moteur), 12.537.187 kr, vann Jubileumspokalen och Paralympiatravet, samt slutade tvåa i Elitloppet och Oslo Grand Prix och trea i Derbyt.</li>



<li>2022 <strong>Francesco Zet </strong>(e. Father Patrick), 20.205.000 kr, vann Sprintermästaren, Derbyt, Breeders Crown, Margareta Wallenius-Klebergs Pokal och Norrbottens Stora Pris.</li>



<li>2023 <strong>Staro Mack Crowe</strong> (e. Bold Eagle), 3.072.176 kr, tvåa i Sprintermästaren och trea i Europaderbyt.</li>
</ul>



<p class="wp-block-paragraph">Hästen som visade störst stjärnstatus som treåring var Timo Nurmos-tränade <strong>Fame And Glory</strong> (e. Tactical Landing), som när han vann Svenskt Travkriterium i livets sjätte start fortfarande inte visste hur det kändes att förlora. Säsongen avslutades med två andraplatser – semifinal och final i Breeders Crown.</p>



<p class="wp-block-paragraph">Nu väntar årsdebut och första starten på sju månader när han ställs mot idel motståndare med flera lopp i kroppen. Björn Goop kör som vanligt och Fame And Glory drog sjundespår bakom bilen.</p>



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



<p class="has-drop-cap wp-block-paragraph">2På tal om hästar med stjärnglans. De flesta travares meritlistor bleknar vid jämförelsen med superstoet <strong>Joviality</strong> (e. Chapter Seven). Förra året skrev hon även in sig i segerlistan för de fyraåriga stonas uppgörelse Prix Diana Zet med 400.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Någon häst av Jovialitys kaliber finns förstås inte i årets upplaga, där Timo Nurmos lanserar ytterligare en årsdebutant i fjolårets vinnare av Svenskt Trav-Oaks, <strong>Adriatica</strong> (e. Bold Eagle). Precis som kull- och stallkamraten Fame And Glory avslutade Adriatica fjolåret med en andraplats i Breeders Crown-finalen.</p>



<p class="wp-block-paragraph">Där fick hon se sig besegrad av Paul Hagoorts italienska sto <strong>Ester Degli Dei </strong>(e. Maharajah), som är tillbaka på svensk mark på måndag i uttagningslopp till Stosprintern i Halmstad.</p>



<p class="wp-block-paragraph">Främsta utmanaren till Adriatica ikväll är kanske istället en annan häst tränad i Nederländerna. Erwin Bot gjorde framgångsrika besök i Sverige förra året med <strong>Ninetta Boko</strong> (e. Father Patrick), som slutade tåva i Oaks och trea i Breeders Crown, båda gångerna med Adriatica framför sig vid målgång.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Kvällens tävlingar är Solvalla enda onsdagskväll i sommar inför den riktiga höjdaren med Margareta Wallenius-Klebergs Pokal den 14 augusti och innehåller många godbitar vid sidan om fyraåringsloppet.</p>



<p class="wp-block-paragraph">Stefan Melanders Elitloppsvinnare från 2010 <strong>Iceland</strong> (e. Scarlet Knight) hade även vunnit Jubileumspokalen året före och femåringsloppet för högsta klassen bär hingstens namn.</p>



<p class="wp-block-paragraph">Melander verkar sugen på en inteckning – han tränar nämligen tre av tio hästar i loppet. Det stora namnet är Elitloppshästen <strong>Decision Maker</strong> (e. Nuncio), som gör första starten efter att ha tröttnat i ledningen i sitt Elitloppsförsök efter 1.09,7 första kilometern. Hon får sällskap av E3-vinnaren Following och Letsdoit, båda söner till Nuncio.</p>



<p class="wp-block-paragraph">Loppet håller hög klass. Johan Untersteiner tar ut fyrfaldige miljonären <strong>Dancer Brodde</strong> (e. Raja Mirchi), som galopperade i Prins Carl Philips Jubileumspokal i årets enda start, Paul Hagoort startar fjolårets tyske Derbytvåa <strong>Y.Not Diamant</strong> (e. Odessa Santana), vilken vann sin Sverigedebut för tre veckor sedan, Gennaro Casillo kommer med kapable <strong>Demon</strong> (e. Royal Blessed) och Alessandro Gocciadoros bidrag är <strong>Danger Bi </strong>(e. Bird Parker).</p>



<p class="wp-block-paragraph">––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-06-19_5_3" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-06-19_5_3" target="_blank" rel="noreferrer noopener">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



<p class="wp-block-paragraph">Förutom på Solvalla blir det även tävlingar i Gävle (start 15.45) i eftermiddag när breddlopp står på menyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/06/240619.pdf">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4På Le Bouscat-banan i Bordeaux (första start kl. 13.23) avgörs årets sjunde etapp av den franska, rikstäckande löpningsserien Grand National du Trot (€90.000).</p>



<p class="wp-block-paragraph">Det är 16 hästar som drabbar samman på högervarvsbanan och sällskapet får i någon mån anses vara profilfattigt då trion <strong>Igrec de Celland</strong> (e. Django Riff), <strong>Hidalgo des Noes </strong>(e. Opium) och <strong>Floreal</strong> (e. Up And Quick) utgör de mest betrodda från tilläggsvolten i detta lopp där vinnaren belönas med 40.500 euro.</p>



<p class="wp-block-paragraph">I evakueringsloppet Prix Caliceo Bordeaux (€35.000) tävlar därtill två svenskfödda hästar. Laurent Claude Abrivards <strong>Marion Fouty Bon</strong> (e. Mister J.P.) går upp i ringen mot Matthieu Abrivards <strong>Filippa B.J.</strong> (e. Muscle Mass) i strid om segerchecken på 15.750 euro.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/marionfoutybonjkm220914adamstromstalltz-617x374.jpg" alt="" class="wp-image-354800"/><figcaption class="wp-element-caption">Marion Founty Bon vid seger på Solvalla. Foto: Adam Ström/stalltz.se</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">5Fjolårets norska Derbystovinnare <strong>Cabaret Artist</strong> (e. Propulsion) 1.11,7ak/2.069.635 kr har inte synts på tävlingsbanan sedan hon blev diskvalificerad i Diamantstoet i april och togs ut från Daniel Redéns träningslista kort senare.</p>



<p class="wp-block-paragraph">Anledningen är helt sonika att det nu femåriga stoet gjort bokslut med fyra segrar på 20 starter.<br>&#8221;<em>Hon har blivit betäckt med Francesco Zet</em>&#8221;, skriver Daniel Redén i ett sms.</p>



<p class="wp-block-paragraph">Utöver segern i Derbystoet i Norge slutade även Cabaret Artist tvåa i fjolårets Breeders Crown-final för ston.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Estländaren Märt Pello fortsätter dominera i lärlings- och amatörloppen.<br><strong>Kendrick K.W.</strong> (e. Maharajah) var hans femte segergods på svensk mark under året på åtta försök och nu står Pello med fyra raka segrar som kusk sedan den 28 maj.</p>



<p class="wp-block-paragraph">Den som vill rygga Pello i hans jakt på femte raka kusksegern får vara på tårna i morgon då han kör <strong>Tenoutoften</strong> (e. Maharajah) åt arbetsgivare André Eklundh i Mantorps sjunde lopp.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Johan Arkland och Jim Oscarssons <strong>Macron Hanover </strong>(e. Ready Cash-Muscaloosa), 1.16,2am/33.500 kr, har nedkommit med en dotter efter Tactical Landing på Blädingeås Stuteri i Vislanda. Tactical Landing blir också Macron Hanovers partner i år.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/macronhanover-350x503.jpg" alt="" class="wp-image-598320"/><figcaption class="wp-element-caption">Macron Hanovers dotter efter Tactical Landing. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">USA-födda Macron Hanover har en avkomma sedan tidigare och förra året fick hon en hingst efter Maharajah. </p>



<p class="wp-block-paragraph">Modern köptes i Harrisburg som ettåring för 30.000 dollar. Hon är undan ostartade <strong>Muscaloosa</strong> (e. Muscles Yankee), vilken lämnat <strong>Walter White </strong>(e. Cantab Hall), 1.09,7/$582.725, och <strong>Mosconi Hanover</strong> (e. Donato Hanover), 1.10,9/$197.434.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Morgonsvepet
Läs senare
Tänds en ny stjärna?
Om dagens stortävlingar på Solvalla, svenskhopp i högervarv och en estländare som inte kan sluta vinna travlopp går bland annat att läsa i veckans tredje morgonsvep.
