
<p class="has-drop-cap wp-block-paragraph">1 Nio fyraåriga hingstar och valacker gör upp om 600.000 kronor i förstapris i Prix Readly Express på Sovlalla (första start 18.30) 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"><em>Eller vad sägs om vad dessa vinnare följde upp med efter triumfen i Prix Readly Express:</em></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.276.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), 11.037.540 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), 16.875.000 kr, vann Sprintermästaren, Derbyt, Breeders Crown och Norrbottens Stora Pris.</li>
</ul>



<p class="wp-block-paragraph">De främsta meriterna hittills bland hästarna i årets upplaga har <strong>Bedazzled Sox</strong> (e. Brillantissime), som utsågs till Årets treåring i Sverige förra året efter att ha tagit största prischecken i långa E3.</p>



<p class="wp-block-paragraph">Årets säsong har inletts med två segrar och tredjeplatsen i Kungapokalen och nu kommer nästa steg i matchningen mot säsongens stora mål: Svenskt Travderby på Jägersro den 3 september.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 De fyraåriga stona gör upp om 400.000 kronor i Prix Diana Zet, som hade premiär förra året med <strong>Glamorous Rain</strong> (e. Muscle Hill) som vinnare. Årets treåriga sto i Nordamerika utsågs <strong>Joviality</strong> (e. Chapter Seven) till och den sagolika karriären har hittills inbringat över 18,6 miljoner kronor.</p>



<p class="wp-block-paragraph">Sedan återkomsten till Sverige har hon vunnit försök-final i Drottningpokalen och slutat tvåa i Fyraåringseliten på 1.09,7ak i Sabine Kagebrants regi.</p>



<p class="wp-block-paragraph">De meriterna är inte hennes medsystrar i närheten av, men Joviality ställs mot två svenska grupp I-vinnare. Jörgen Westholms ston <strong>Sparven</strong> (e. Bird Parker) och <strong>Queen Belina</strong> (e. Nuncio) vann nämligen långa E3 respektive Breeders Crown förra året och har båda sina årsdebuter överstökade.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/sparvenmfadam-617x333.jpeg" alt="" class="wp-image-336727"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade Sparven startar i Prix Diana Zet. 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">3 Kvällens tävlingar är Solvallas första av två onsdagskvällar i sommar inför den riktiga höjdaren med Jubileumspokalen den 16 augusti och kvällens program innehåller många godbitar.</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 kvällens femåringslopp för högsta klassen har fått hingstens namn. Sex svenskfödda hästar möter italienske Derbyvinnaren <strong>Charmant de Zack </strong>(e. Vivid Wise As) i kamp om 150.000 kronor.</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/206233_V86_2023-06-21_5_3" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



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



<p class="wp-block-paragraph">Utanför V86-kupongen avgörs det första uttagningsloppet till Breeders Course över kort distans för treåringar med final på Jägersro på Åbergskvällen den 25 juli och 800.000 kronor i förstapris. De två främsta från kvällens försök får plats där. Övriga uttagningslopp körs på Åby 29 juni, Jägersro 11 juli, Wolvega 13 juli och Neapel 14 juli.</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/2023/06/230621.pdf" target="_blank" rel="noreferrer noopener">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">4 I Langon (första start 16.23) drygt 60 mil sydväst om Paris avgörs ikväll årets sjunde etapp av löpningsserien Grand National du Trot (€90.000).<br>Sébastien Guaratos <strong>Horace du Goutier</strong> (e. Ready Cash) kommer till start med två raka GNT-segrar i ryggen, men i de loppen har han inlett på startvolten.</p>



<p class="wp-block-paragraph">Idag jagar han från 25 meters tillägg ihop med Hughes Monthule och möter en annan GNT-kändis i Jean Michel Baudouins <strong>Gaspar d&#8217;Angis</strong> (e. Quaro) som är än värre med tre GNT-segrar under året!</p>



<p class="wp-block-paragraph">Till Langon får även Christoffer Erikssons <strong>Self Explosive</strong> (e. Explosive Matter) bege för start i Prix Bordelaise de Lunetterie (€33.000).<br>Alexandre Abrivard sitter på ryggen när åttaåringen är på jakt efter sin femte årsseger och bland konkurrenterna syns Alexandre Vissocqs svenskfödde <strong>Myllkärrs Medua</strong> (e. The Bank).<br>Tävlingsdagens tredje svenskintresse noteras i evakueringsloppet Prix Sweet Valentine Traiteur (€29.000) där Tomas Malmqvist luftar <strong>Kapitano de Source</strong> (e. Ready Cash) i lag med Eric Raffin.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/langon-2023-06-21/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Langon.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5 Anders Svanstedt-tränade <strong>Isle</strong> (e. Muscle Massive) var den enda svensktränade hästen när Ålborg arrangerade sex kval till Grand Circle för treåringar under tisdagen.</p>



<p class="wp-block-paragraph">Någon lycka blev det dock inte för stoet i lag med Birger Jörgensen utan hon fick helt enkelt se sig frånsprungen trots en perfekt resa som tredjehäst längs sargen med fritt spurtutrymme i god tid och slutade oplacerad.<br>Finalerna avgörs likaså i Ålborg fredag den 7 juli över 2.140 meter autostart och med 204.000 danska kronor till vinnaren i respektive klass.</p>



<p class="wp-block-paragraph">Nedan följer samtliga finalister av respektive klass, hästarna i kursiv stil vann uttagningslopp.</p>



<p class="wp-block-paragraph"><strong>Finalister Grand Circle för treåriga hingstar och valacker</strong></p>



<ul class="wp-block-list">
<li><em>Just Hans (e. Maharajah) – Bent Svendsen</em></li>



<li>In My Way Damgård (e. Papagayo E.) – Bo Westergård</li>



<li>Jr (e. Orlando Vici) – Jeppe Juel</li>



<li>Impressive Hancock (e. Muscle Massive) – Steen Juul</li>



<li><em>Jefferson (e. S.J.&#8217;s Caviar) – Steen Juul</em></li>



<li>Jubii Vang (e. Maharajah) – Bo Westergård</li>



<li>Joy Me (e. Luckycharm Hanover) – Mariann T Nielsen</li>



<li>J J (e. Orlando Vici) – Jeppe Juel</li>



<li><em>Iceman (e. Wishing Stone) – Dennis Kristiansen</em></li>



<li>Icebreaker (e. Chocolatier) – Jeppe Juel</li>



<li>Ikon Vang (e. Southwind Frank) – Bo Westergård</li>



<li>Indeed (e. Trixton) – Peter Spengler</li>
</ul>



<p class="wp-block-paragraph"><strong>Finalister Grand Circle för treåriga ston</strong></p>



<ul class="wp-block-list">
<li><em>Jamaica Gardenia (e. Ens Snapshot) – Torben Hovgaard</em></li>



<li>Jazz Laser (e. Bvlgari Peak) – Anders Pedersen</li>



<li>Joyce Aveve (e. Weingartner) – Peter Rasmussen</li>



<li>Ironheart (e. Maharajah) – Anders Jensen</li>



<li><em>Just A Lady (e. S.J.&#8217;s Photo) – Bo Westergård</em></li>



<li>Ivana Nordic (e. Explosive Matter) – Bo Westergård</li>



<li>Jackie Wee (e. Maharajah) – Bent Svendsen</li>



<li>Iloveyou Butcher (e. Dominion Beach) – Magnus Ladegaard</li>



<li><em>Isabella C N (e. Dream Vacation) – Bo Westergård</em></li>



<li>Jacqueline Mosebo (e. Great Challenger) – Steen Juul</li>



<li>Innocence (e. Gigant Neo) – Knud Mönster</li>



<li>Iconic Sotto (e. Bird Parker) – Morten Juul</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">6 Travsporten gästspelade på Bro Parks galoppbana under tisdagkvällen då det kördes ett sulky- samt reds ett montélopp på gräsbanan.</p>



<p class="wp-block-paragraph">Linus Lönn vann sulkyloppet med Fredrik Wallin-tränade <strong>Donatello Wibb</strong> (e. Donato Hanover) på 1.19,0/2.140 meter och samme tränare hade en vinnare i sadelloppet då <strong>Bad Manner</strong> (e. Lucky Chucky) vann på 1.17,6/2.140 meter i lag med Jonathan Carre.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/skarmavbild20230620kl.18.43.12-617x345.jpg" alt="" class="wp-image-460743"/><figcaption class="wp-element-caption">Travhästarna intog galoppbanan Bro Park under tisdagkvällen. Foto: Skärmdump ATG Live.</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">7 Johan Untersteiner har stärkt upp stallet med en segervan femåring. <strong>Oktan Håleryd</strong> (e. Bold Eagle) 1.13,4ak/282.000 kr har inlett karriären med sex segrar på 14 starter i Robert Dunders regi, men finns sedan början av juni söderut då han nu är en av 160 hästar på Halmstadproffsets träningslista.</p>



<p class="wp-block-paragraph">Oktan Håleryd är halvbror med miljonärerna<strong> Isor Håleryd</strong> (e. Ready Cash) 1.12,5al/1.670.300 kr och <strong>Delux Håleryd</strong> (e. Jag de Bellouet) 1.13,0ak/1.062.850 kr.</p>

Fokustema
Morgonsvepet
Läs senare
Solvallas superkväll
Om kvällens topptävlingar på Solvalla, Grand National du Trot-etappen i sydvästra Frankrike samt gårdagskvällens storloppskval i Ålborg kan du bland annat läsa i dagens morgonsvep.
