
<p class="has-drop-cap">1Medan <a href="https://sv.wikipedia.org/wiki/Landstigningen_i_Normandie" target="_blank" rel="noreferrer noopener">Dagen D av landstigningen i Normandie år 1944</a> hade ett öppet datum länge och väl som kunde infalla lite när som helst så har datumet för Elitloppets Dagen D i Normandie varit känt sedan länge.</p>



<p>Att Prix de Ducs de Normandie (€150.000) skulle infalla lördag den 11 maj är på intet vis en nyhet och därtill ett datum som etsat sig fast i många travintresserades minne.</p>



<p>Idag ska nämligen Elitloppsfavoriten tillika Prix d&#8217;Amerique-vinnaren <strong>Idao de Tillard</strong> (e. Severino) genrepa inför sitt framträdande på Solvalla och alla (utom konkurrenterna, möjligtvis&#8230;) håller tummarna för att Thierry Duvaldestins stjärna ska leverera.<br>– <em>Hästen har inte tävlat på två månader och tolv dagar. Han behöver ett riktigt lopp inför Elitloppet om två veckor. Idao de Tillard kan både vinna och vara fyra och ändå gjort en mycket bra insats</em>, <a href="https://sulkysport.se/allt-gar-inte-som-planerat/">säger Thierry Duvaldestin till Paris Turf.</a></p>



<p>Klockan 15.15 avgörs loppet, spelbolaget ATG arrangerar V4-spel till tävlingarna och spelbolaget Svenska Spel arrangerar i sin tur Quinté-spel – eller High Five som det benämns i Sverige – till loppet i fråga som även innehåller fjolårets Elitloppsvinnare <strong>Hohneck</strong> (e. Royal Dream).</p>



<h2 class="wp-block-heading">Startlista:</h2>



<p><strong>Prix des Ducs de Normandie</strong> (€150.000)<br><strong>Priser:</strong> 67.500-37.500-21.000-12.000-7.500-3.000-1.500 euro<br><em>2.450 meter.</em></p>



<p><strong>Namn – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Fulton</strong> – Romain Congard</li>



<li><strong>Gamay de l’Iton</strong> – Francois Lagadeuc</li>



<li><strong>Gaspar de Brion</strong> – Matthieu Abrivard</li>



<li><strong>Eric the Eel </strong>– Eric Raffin</li>



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



<li><strong>Echo de Chanlecy</strong> – Tony Le Beller</li>



<li><strong>Fakir du Lorault</strong> – Francois Lecanu</li>



<li><strong>Emeraude de Bais</strong> – Franck Nivard</li>



<li><strong>Izoard Vedaquais</strong> – Benjamin Rochard</li>



<li><strong>Hanna des Molles </strong>– Leo Abrivard</li>



<li><strong>Elvis du Vallon</strong> – Yoann Lebourgeois</li>



<li><strong>Hirondelle du Rib</strong> – Jean-Loïc Claude Dersoir</li>



<li><strong>Hokkaido Jiel</strong> – David Thomain</li>



<li><strong>Hooker Berry</strong> – Nicolas Bazire</li>



<li><strong>Idao de Tillard</strong> – Clement Duvaldestin</li>



<li><strong>Hohneck</strong> – Gabriele Gelormini</li>
</ol>



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



<p class="has-drop-cap">2Umåkers gulddivisionslopp Guldbjörken har sedan tidigt 1990-tal alltid avgjorts runt månadsskiftet april-maj. Döljer det sig några blivande Elitloppshästar i årets upplaga som samlat en hel del spännande namn i kamp om 200.000 kronor i förstapris?</p>



<p>Daniel Wäjersten är titelförsvarare i loppet efter <strong>Global Badmans</strong> (e. Yield Boko) triumf förra året, men då denne tävlade på Hagmyren igår laddar Wäjersten istället med en färsk Grupp I-vinnare respektive en sexfaldig miljonär. Det handlar om Borups Victory (e. Googoo Gaagaa) och<strong> Rome Pays Off </strong>(e. Muscle Hill).</p>



<p>Efter triumfen i Seinäjoki Race tackade Wäjersten nej till start i sprinterloppet Finlandia-Ajo med Borups Victory för att istället tävla i Guldbjörken över medeldistans. Faktum är att Borups Victory bara i en av livets 30 starter testat kort distans, i livets andra start på hösten som tvååring då han tränades av Robert Bergh.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/borupsvictorydwm230204adamstromstalltz-617x406.jpg" alt="" class="wp-image-407371"/><figcaption class="wp-element-caption">Borups Victory och Daniel Wäjersten. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Nu har han fjärdespår bakom bilen med startkatapulten<strong> Castor the Star</strong> (e. Maharajah) två spår utanför.<br>– <em>Han får sköta sig själv första biten och sedan får vi se var vi hamnar. En gång har jag laddat ordentligt, på Solvalla från spår ett i en silverfinal, och då öppnade han riktigt bra, men jag kommer inte stirra mig blind på Castor the Star utan min häst får gå iväg och få ett lopp till i kroppen inför säsongen</em>, sade Daniel Wäjersten till V65 Direkt.</p>



<p>Annars tackar han inte nej om det skulle komma en inbjudan till Elitloppet framöver:<br>– <em>Om han får en inbjudan vill vill gärna vara med om han är pigg och fräsch som han verkar. Nu är det upp till oss att bevisa att han förtjänar en biljett. Vi har försökt sedan november för att se om vi kan nå Elitloppet. Han känns kännefin i träning, vi har tränat lite annorlunda än förra året, mer rakbana än backe</em>, sade Wäjersten.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Guldbjörken:</h2>



<p><em>År, vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2014 <strong>Hard Livin</strong> (e. S.J.’s Caviar) – Daniel Redén – 1.11,4a*</li>



<li>2019<strong> Muscle Hustle </strong>(e. Muscle Mass) – Robert Bergh – 1.11,5a</li>



<li>2015 <strong>Nahar</strong> (e. Love You) – Roberg Bergh – 1.11,6a*</li>



<li>2018 <strong>Beau Mec</strong> (e. Jag de Bellouet) – Carl Johan Jepson (Lars Wikström) – 1.11,6a</li>



<li>2023<strong> Global Badman </strong>(e. Yield Boko) – Daniel Wäjersten – 1.11,7a</li>



<li>2022<strong> Don Fanucci Zet </strong>(e. Hard Livin) – Örjan Kihlström (Daniel Redén) – 1.11,8a</li>



<li>2012 <strong>Sanity</strong> (e. Love You) – Johnny Takter (Malin Löfgren) – 1.11,9a</li>
</ul>



<p>*Hard Livin och Nahar tog sina segrar över kort distans, övriga vinnare över medeldistans.</p>



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



<p class="has-drop-cap">3I fjolårets form hade han varit ett givet vinnartips och favorit till biljetten till Elitkampen på Solvalla med en miljon kronor till vinnaren. Men hur står det egentligen till med formen hos fjolårets kallblodskomet <strong>Bäcklös Uriel</strong> (e. Smedheim Solan)? 2023 var nämligen ett riktigt succéår med tio segrar och nya segerrekordet 1.18,7a/1.640 meter – bara <strong>Järvsöfaks</strong> har travat snabbare av svenska kallblod genom tiderna.</p>



<p>Men årsdebuten på Hagmyren för fyra veckor sedan lämnade mycket övrigt att önska när Bäcklös Uriel gjorde en riktigt slät figur och var långt efter näst sista häst i loppet. I eftermiddag i Vårbjörken väntar sprinterdistans och innerspår bakom bilen.<br>– <em>Bäcklös Uriel jagar formen fortfarande och med tanke på senaste prestationen behöver han lopp i kroppen och det är inte toppform nu. Prestationen i årsdebuten var lite sämre än vi tänkt även om det var väntat att han inte skulle vara i form. Vi har meckat på lite efter, men han hamnade efter en månad i vintras och det har suttit i. Drömmen är att han ska vara med i Elitkampen om två veckor</em>, sade Marcus Lilius i stallet till V65 Direkt.</p>



<p>Hagmyrenkusken håller stallkamraterna Järvsöodin (e. Järvsöfaks), som han kör själv, och startkatapulten<strong> B.W.Sture</strong> (e. Moe Odin), som bättre segerchanser.</p>



<p>Löpningsrekordet tillhör<strong> Lome Brage</strong> (e. H.G.Balder) som travade 1.20,4a för fyra år sedan. Kanske är det dags att 1.20-vallen sprängs nu?</p>



<p>Tre hästar är hittills inbjudna till Elitkampen: fjolårsvinnaren <strong>Evartti</strong> (e. K.M.Nopsa), tvåan <strong>Tangen Bork </strong>(e. Bork Odin) och<strong> Månlykke A.M. </strong>(e. Månprinsen A.M.).</p>



<p>Det är jackpot på V75 och ATG beräknar att sjurättspotten kommer att innehålla 44 miljoner kronor, varav cirka 18,5 miljoner kronor extra. Sulkysports expert Emil Persson har synat omgången noga.</p>



<p>”<em>Vi går ut hårt och spikar Tomas Petterssons <strong>From the Hip </strong>(V75-1) i det inledande Klass II-försöket. Vi gillade verkligen vad vi såg av denna häst i inledningen av karriären, tycker att han återfunnit stilen med besked under våren och tror att han pallar ett offensivt upplägg i det här sammanhanget. Uppgiften är riktigt kittlande och spelprocenten på under tio procent löjligt låg</em>.”</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-11-maj/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången med analyser, spetsstrider, systemförslag och ranking av alla hästar.</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-05-11_27_5" class="">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-05-11_27_5" class="">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap">4På kvällens Travera-auktion säljs elva starthästar och en tvååring. Bland starthästarna noteras treårige Numbertwentyone (e. Maharajah) 1.14,8am/196.400 kr som var femma i finalen av Norrlands Elitserie ifjol samt halvmiljonärerna <strong>Cornerstone</strong> (e. Wellino Boko) 1.12,0ak/563.076 kr och <strong>Holdfast Am</strong> (e. Chapter Seven) 1.11,3ak/572.756 kr vilka båda är lördagsmeriterade.</p>



<p><a href="https://www.travera.nu/" target="_blank" rel="noreferrer noopener">Här kan du ta del av utbudet på kvällens Travera-auktion som drar igång klockan 19.15.</a></p>



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



<p class="has-drop-cap">5Idag arrangerar Ålandstravet (första start kl. 19.00) sin första av totalt fyra tävlingsdagar för året.<br>Det travas även lördag den 8 juni, lördag den 3 juli samt lördag den 3 augusti och vid samtliga tävlingstillfällen arrangerar spelbolaget ATG V65-spel till tävlingarna.</p>



<p>Det är som vanligt gott om svenskintressen på Mariehamn och höjdpunkten får anses vara V65-spelets femte avdelning där Jonas Gyllings V75-tvåa <strong>Cardin</strong> (e. Maharajah) möter Conny Mikael Janssons nyförvärv <strong>Hot Dansk Dynamite</strong> (e. Partout Simoni).<br>Den sistnämnde ropades in för 350.000 kronor på Travera-auktionen den 13 april och kommer till start med tre raka segrar varav de två senaste är tagna på Solvalla i 60.000 kronorslopp, men ikväll är det blott 1.784 euro som väntar vinnaren.</p>



<p>På svensk mark tävlas det förutom på Umåker även i Tingsryd (första start 11.10).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/05/240511.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap">6Även om Prix de Ducs de Normandie avgörs utan svenskhopp i Caen (första start kl. 13.23) så går det skönja blågula intressen i ett annat lopp under tävlingsdagen.</p>



<p>I inledningsloppet Prix de Cambremer (€29.000) för sju- till nioåriga hästar som tjänat upp till 136.000 euro startar nämligen fyra svenskfödda, men till Frankrike exporterade hästar.</p>



<p>Dominik Locqueneux bidrar med <strong>Halo Am</strong> (e. Father Patrick) som anses vara det hetaste kortet, Jean Charles Piton med<strong> Musett af Djupmyra</strong> (e. Super Photo Kosmos) och Lieven Cannaert med <strong>Reddington</strong> (e. From Above).</p>



<p>Under eftermiddagen avgörs även det Grupp III-klassade fyraåringsloppet Prix Guillaume Le Conquerant (€80.000) med Philippe Allaires<strong> Koctel du Dain</strong> (e. Boccador de Simm) som huvudrollsinnehavare samt det Grupp II-klassade sadelloppet Prix Henri Balliere (€120.000) för de bästa inhemska fyraåringarna med <strong>Kyrielle des Vaux </strong>(e. Rolling d&#8217;Heripre) som favorit.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/caen-2024-05-11/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Caen.</a></p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/tonnac4-617x295.jpg" alt="" class="wp-image-574259"/><figcaption class="wp-element-caption">Invändige Koctel du Dain håller undan för Krack Time Atout (11) på Enghien för tre veckor sedan. Foto: Gerard Forni</figcaption></figure>



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



<p class="has-drop-cap">7Ston står i centrum när det travas på norska Biri (första start kl. 14.10) under eftermiddagen.</p>



<p>På varmblodssidan får Frode Hamre-tränade <strong>Bunny</strong> (e. Born in the U.S.A.) inta favoritrollen i ett lopp där det största svenskintresset är Kristian Malmins Kashmina B.R. (e. Muscle Hill) som nu genrepar inför Diamantstofinalen på Solvalla under Elitloppshelgen.<br>Stoet gör &#8221;minicomeback&#8221; efter att haft tävlingsfri period efter försöksvinsten på Bjerke den 16 mars.</p>



<p>Hamre har även kallblodsloppets mest betrodda häst i form av <strong>Nordsjö Anna </strong>(e. Tekno Odin). Den forna vinnaren av såväl svenska som norska Derbystoet inleder från ett innerspår i sitt lopp som avslutar tävlingsdagens nio loppsutbud.</p>

Fokustema
Morgonsvepet
Läs senare
Dagen D i Normandie
Om Idao de Tillards genrep inför Elitloppet, dagens tävlingar på Umåker där båda varma- och kalla toppar jagar E-helgsplatser samt en intressant duell under Ålandstravets årspremiär går bland annat att läsa i veckans sjätte morgonsvep.
