
<p class="has-drop-cap">1Klockan 16:35 avgörs dagens med råge mest intressanta travlopp på europeisk mark.</p>



<p>Det handlar om Grupp I-klassade Prix Rene Balliere (€200.000) på Vincennes där det är profilstarkt så det förslår.</p>



<p>Den färska Elitloppsvinnaren<strong> Horsy Dream </strong>(e. Scipion du Goutier) gör sin första start efter uppvisningen på Solvalla och där övertygade även <strong>Izoard Vedaquias</strong> (e. Bird Parker) stort då han krossade sina konkurrenter i Harper Hanovers lopp.</p>



<p>Ovanpå det läggs Prix d&#8217;Amerique-vinnaren<strong> Idao de Tillard</strong> (e. Severino) till sin krydda på moset liksom PDA-tvåan <strong>Hokkaido Jiel </strong>(e. Brillantissime) och den trefaldiga euromiljonären <strong>Vivid Wise As</strong> (e. Yankee Glide).</p>



<p>Om Horsy Dream vinner dagens Prix Rene Balliere så blir han den första franskfödda hästen att lyckas med dubbeln Elitloppet-Balliere sedan Ianthin vann år 1983. Dubbeln har också tagits av <strong>Sea Cove</strong> (1993) och<strong> Exploit Caf</strong> (2008), men där pratar vi om en icke franskfödd duo.</p>



<h2 class="wp-block-heading">Startlista Prix René Ballière (€200.000)</h2>



<p><strong>4-11 år, 2.100 meter, autostart (nio hästar bakom bilen).</strong><br><strong>Priser: </strong>90.000-50.000-28.000-16.000-10.000-4.000-2.000 euro<br><em>Namn – Körsven (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Vivid Wise As</strong> – Matthieu Abrivard (Alessandro Gocciadoro)</li>



<li><strong>Elvis du Vallon</strong> – Yoann Lebourgeois (Charles Cuiller)</li>



<li><strong>Inmarosa</strong> – Leo Abrivard (Laurent-Claude Abrivard)</li>



<li><strong>Idao de Tillard</strong> – Clement Duvaldestin (Thierry Duvaldestin)</li>



<li><strong>Hokkaido Jiel</strong> – David Thomain (Jean-Luc Dersoir)</li>



<li><strong>Gamay de l’Iton</strong>– Francois Lagadeuc (Hughes Levesque)</li>



<li><strong>Horsy Dream</strong> – Eric Raffin (Pierre Belloche)</li>



<li><strong>Ganay de Banville</strong> – Jean-Michel Bazire</li>



<li><strong>Izoard Vedaquais</strong> – Benjamin Rochard (Philippe Allaire)</li>



<li><strong>Diva del Ronco</strong> – Mario Minipoli Jr (Salvatore Minopoli)</li>



<li><strong>Desiderio d’Esi</strong> – Marco Stefani (Mauro Baroncini)</li>



<li><strong>Hede Darling</strong> – Nicolas Bazire (Jean-Michel Bazire)</li>
</ol>



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



<p class="has-drop-cap">2Kalmartravets förra storstjärna var <strong>Viola Silas</strong> (e. Lindy Lane), 1.10,9ak*/6 742 760 kr. Den nya stjärnan heter <strong>A Fair Day</strong> (e. Maharajah), 1.09,4ak*/3.230.000 kr. Idag på Kalmartravet (första satrt 14.45) är det fokus på båda hästarna – fast på olika sätt.</p>



<p>Fredrik Perssons stostjärna Viola Silas hyllas med sitt eget lopp i stoeliten, medan Elisabeth Almhedens femåring A Fair Day kommer ut i Kalmarsundspokalen tillsammans med hemmaamatören Oscar Ginman.</p>



<p>Viola Silas meritlista innehöll segrar i Guldstoet, korta E3 och Breeders Crown som treåring (Viola Silas var inte anmäld till Oaks), samt Drottningpokalen, Stochampionatet och Derbystoet som fyråring innan hon året efter segrade i Prins Daniels lopp.</p>



<p>A Fair Day har en bit att vandra till de meriterna, men kan skryta med fyraåringssegern i Breeders Crown och vårens triumf i Prins Carl Philips Jubileumslopp, vilket gav en biljett till Elitloppet.</p>



<p>Det elddopet tog dock dlut innan det började när A Fair Day galopperade kort efter start i Elitloppsförsöket. Efteråt har det varit besök hos veterinären och full laddning mot hemmabanans gulddivisionslopp i eftermiddag.<br>– Jag tycker att han är lite svårbedömd även om hästen känns fantastiskt laddad och verkligen är redo. Innan årsdebuten så körde vi ett ganska tufft jobb med honom med tanke på att ha honom riktigt väl förberedd. Det upplägget har vi inte gjort den här gången, samtidigt har han några starter i kroppen som säkert har fört fram honom en del, säger tränare Almheden till Kanal75.</p>



<p>A Fair Day brottas med bakspår i Kalmarsundspokalen och ställs mot motståndare som forne Elitloppsvinnaren <strong>Don Fanucci Zet</strong> (e. Hard Livin) och årets Elitloppstrea <strong>Denver Gio</strong> (e. Southwind Frank).</p>



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



<p class="has-drop-cap">3Över 32 miljoner kronor extra ligger i sjurättspotten i Kalmar idag efter förra veckans favoritparad i Boden och Sulkysports tipsexpert har gnuggat geniknälarna.</p>



<p>”<em>Vi spelar med dubbla singelstreck. <strong>Never Mind’em</strong> (V75-1) har god chans att lösa Bronsdivisionen där vi ser honom som överkvalificerad och främst tävlande mot sig själv. Maroon Day (V75-5) tycker vi därtill är en för bra häst för Klass II och tror på spets och leverans trots spår sju bakom startbilsvingen</em>.”</p>



<p>Daniel Redén tränar Never Mind’em (e. Propulsion), som vann bronsförsök i Umeå i mitten av maj men galopperade bort sig i finalen på Solvalla två veckor senare.<br>– <em>Han såg lite lojare ut hela dagen senast på ”Valla” så jag vet inte var det var. Det var flera hästar från det stallet som inte riktigt var som de brukar just den tävlingsdagen och Never var en av dem. Jag vet inte on det berodde på att de ätit grönt gräs den veckan. Nu går vi vidare, jag körde honom i måndags och han var jättefin. Han klarar att resa och har fint spår bakom bilen så han kommer nog göra ett bra lopp</em>, säger Daniel Redén till Stall Zets hemsida.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/06/23v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Kalmar.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-06-23_19_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-06-23_19_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/violasilasmal-617x333.jpg" alt="" class="wp-image-233418"/><figcaption class="wp-element-caption">Viola Silas med Fredrik Persson vann Stochampionatet 2010. Foto Adam Ström/Stalltz.se</figcaption></figure>



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



<p class="has-drop-cap">4Mer Vincennes (första start kl. 13.18) för där avgörs nämligen ytterligare fyra Grupp I-lopp under eftermiddagen!</p>



<p>De inhemska sadelhästarna gör upp i Prix d&#8217;Essai (€200.000) för treåringar, Prix President de la Republique (€200.000) för fyraåringar samt Prix de Normandie (€200.000) för femåringar.</p>



<p>Loppen avgörs utan svenska inslag liksom de treåriga, inhemska sulkyhästarnas Prix Albert Viel (€200.000) där en av förhandsfavoriterna är Jean-Michel Bazires <strong>Liza Josselyn</strong> (e. Ready Cash). Stoet är ultrastammad med Prix d&#8217;Amerique-vinnarna Ready Cash samt Belina Josselyn som föräldrar.</p>



<p>Svenska inslag finns däremot i två andra lopp. I Prix de Grasse (€90.000) för fem- och sexåringar tävlar Jörgen Westholms <strong>Donizetti</strong> (e. Maharajah) samt Erik Bondos svenskfödde <strong>Dowhatyoudodowell</strong> (e. Maharajah) och i Prix de Grosbois (€90.000) syns svenskfödde Gardner Shaw (e. Ready Cash) tränad av Yannick Henry.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-06-23/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5Det var inte bara äldre topphästar som visade upp sig i Orkla såsom Tangen Bork och Moni Viking under gårdagen.</p>



<p>En riktigt fin treåring gick även skönja i Tamin Sandys Minneslopp där vinnaren belönades med 125.000 norska kronor.<br>Geir Vegard Gundersen-tränade <strong>Nadal B.R.</strong> (e. Googoo Gaagaa) vann loppet på urstarka 1.13,3a/2.300 meter vilket var hästens andra seger på fyra försök.</p>



<p>Sedan tidigare har hästen även slutat trea i storloppet Hans Petter Tholfsens Minneslopp.</p>



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



<p class="has-drop-cap">6Midsommarloppet i Lindesberg är en årlig höjdpunkt under just midsommarhelgen.<br>Loppet avgörs i två försök samt final och det blev olika vinnare i loppen. Efter att Mattias Djuse vunnit ett försök med <strong>Global De One</strong> (e. S.J.&#8217;s Caviar) och Mattias P Djuse vunnit det andra försöket med <strong>Illfindmywayhome</strong> (e. Chocolatier) var det Åke Lindbloms <strong>Appasso</strong> (e. Quite Easy U.S.) som tog hem finalen på 1.13,8/2.160 meter där förstapriset uppgick till 75.000 kronor.</p>



<p>Extra noterbart från lördagens tävlingar var att samtliga fyra bröder Djuse vann travlopp runt omkring i Sverige.</p>



<p>Mats E Djuse vann ett lopp i Rättvik, Magnus A Djuse likaså och så tog Mattias samt Martin P Djuse två respektive en vinst i Lindesberg.</p>



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



<p class="has-drop-cap">7Idag avgörs den 139:e upplagan av Österrikiskt Travderby (€50.000). Det står 25.000 euro på spel till vinnaren och det är minst sagt spridda skurar när det kommer till intjänade prispengar såhär långt i karriären bland deltagarna.</p>



<p>Mona Lisa Venus (e. Light Kronos) är &#8221;rikast&#8221; med sina 53.692 euro medan Tolkier (e. Boccaccio) blott nått upp i 1.971 euro.</p>



<p>Jörgen Sjunnesson är på plats i Wien för att köra Franz Konlechner-tränade <strong>Knowu Cucu</strong> (e. Booster Winner).</p>



<p><strong>Startlista Österrikiskt Travderby</strong><br><em>2.600 meter autostart</em></p>



<ol class="wp-block-list">
<li>Financial Times (e. Southwind Frank) – Franz Konlechner</li>



<li>Dilara Venus (e. Light Kronos) – Wolfgang Ruth</li>



<li>Mona Lisa Venus (e. Light Kronos) – Hubert Brandstätter</li>



<li>Vita Venus (e. Incredible Hulk) – Christoph Schwarz</li>



<li>Knowu Cucu (e. Booster Winner) – Jörgen Sjunnesson</li>



<li>Power Hill (e. Muscle Hill) – Gerhard Mayr</li>



<li>Muscle Magic (e. Light Kronos) – Christoph Fischer</li>



<li>Kiwi&#8217;s Starry Sky (e. Muscle Hill) – Cornelia Mayr</li>



<li>Reina KP (e. Napoleon) – Rudolf Haller</li>



<li>HotSummer (e. Crazed) – Dominik Duda</li>



<li>Tolkier (e. Boccaccio) – Harald Sykora</li>



<li>MS Fire (e. Lovely Lidob) – Josef Maier</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Prix d’Amerique vs Elitloppet
Om Elitlopps- och Prix d'Amerique-vinnarnas möte i Paris, dagens topptävlingar i Kalmar samt den 139:e upplagan av Österrikiskt Travderby går bland annat att läsa i dagens morgonsvep.
