
<p class="has-drop-cap wp-block-paragraph">1Ikväll kör Daniel Wäjersten sitt första lopp någonsin på Vincennes (första start kl. 18.58).</p>



<p class="wp-block-paragraph">Prix Melusina (€46.000) för sexåriga hästar som högst tjänat 141.000 euro är uppgiften som stundar för Wäjerstens Titan Yoda och Ready Cash-sonen inleder från spår fem i detta EU-lopp över 2.100 meter autostart där vinnaren kammar hem 20.700 euro.<br>Ytterligare tre svenskhopp finns med genom Erwin Bots <strong>Halo Am</strong> (e. Father Patrick), Stefan Arvidssons <strong>G.K.Justus </strong>(e. Brad de Veluwe) och Björn Goops <strong>Twigs Honor</strong> (e. Voltigeur de Myrt).</p>



<p class="wp-block-paragraph">På Vincennes tävlar även Ron Kuipers <strong>Koko Labelle </strong>(e. Charly du Noyer) i Prix Ottilia (€35.000) och Marie Norbergs <strong>Justess Viking</strong> (e. Ubriaco) i Prix Gienah (€35.000).</p>



<p class="wp-block-paragraph">Dessförinnan är det övningar i Chartres (första start kl. 11.53) och tre hästar med svenskkoppling syns i Prix de la Ville de Brou (€28.000).<br>Jörgen Westholms <strong>Ara</strong> (e. Maharajah), Pierre Levesques <strong>Huis Clos </strong>(e. Bird Parker) och Björn Goops <strong>Nymke Brigadoon </strong>(e. Make It Happen) drabbar samtliga samman och senare under tävlingsdagen tävlar även Jarmo Niskanens <strong>Impactdarche</strong> (e. Quaker Jet) i Prix Le Plat d&#8217;Etain Brou (€18.000) och Jörgen Westholms <strong>Holster</strong> (e. Bird Parker) i Prix Maison de la Presse Brou (€28.000).</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-12-01/" target="_blank">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<h2 class="wp-block-heading">Såhär gick det för svenskarna på Vincennes under gårdagen:</h2>



<p class="wp-block-paragraph"><em>Hästnamn (far) – tränare – placering – intjänade prispengar</em></p>



<ul class="wp-block-list">
<li>Karat River (e. Muscle Hill) – Johan Untersteiner – sexa – 420€</li>



<li>Castor the Star (e. Maharajah) – Jörgen Westholm – oplacerad</li>



<li>Self Explosive (e. Explosive Matter) – Christoffer Eriksson – tvåa – 17.000€</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2Barfotakörning eller skor? Det behöver varken tränare eller spelare tänka på de kommande tre månaderna oavsett väderlek. Idag träder nämligen vinterns barfotaförbud ikraft på svenska banor.</p>



<p class="wp-block-paragraph">Så här skriver svensk Travsport: <em>Definitionen av vad som är ett godkänt beslag under perioden är den samma som tidigare, alltså att det ska vara: en sko som täcker hela bärranden, alternativt höjer hela bärranden från marken som exempelvis päronsko, flappsko eller tåöppen sko. Plastad hov eller tåsko i kombination med plastad hov är inte godkänt.</em></p>



<p class="wp-block-paragraph">Tre svenska banor tävlar idag. Av hästarna till start på Jägersro tävlade närmare hälften med någon form av barfotabalans i sin senaste start. På banorna längre norrut är det inte alls många som tvingas lämna barfotabalansen. Romme var det knappt ett 20-tal som tävlade utan skor i senaste starten, medan det på Umåker inte ens var en handfull.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Romme (första start 18.20) och Umåker (start 18.30) och en riktig vinterspecialist dyker åter upp i björkarnas stad i Västerbotten. Gabriella Laestanders nioåring <strong>Selmer I.H.</strong> (e. Love You) må svar för starta insatser även under varmare perioder av året, men när det kommer till vintern lägger han in en växel till.</p>



<p class="wp-block-paragraph">Från november till och med mars förra vinter gjorde Selmer I.H. elva starter, vann nio och tog två andraplatser! I år har han inlett november med en seger och ett fjärdepris.</p>



<p class="wp-block-paragraph">Jenny Eriksson, amatörtränare med licens på Färjestad, har ett välfyllt stall och reser med fyra hästar till Romme. Bland dessa finns segervane<strong> Mister A. </strong>(e. Mister J.P.) med sex triumfer under 2023 och elva på 25 starter i karriären. Att Jenny och hennes hästar trivs på Romme råder inga tvivel om. De två senaste besöken har slutat med hundraprocentig utdelning i form av segrar.</p>



<p class="wp-block-paragraph">På Jägersros (start 12.20) lunchtävlingar handlar det om en enda proposition som resulterade i åtta spårtrappor. I den högsta klassen sticker Fredrik Perssons toppsto <strong>Deborah S.H. </strong>(e. Maharajah) ut och vid seger kliver hon över två miljoner kronor insprunget i karriären. Fredrik Perssons sto har sin främsta merit i andraplatsen i Drottning Silvias Pokal förra året.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/11/231201.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4När treårige finnhästen <strong>Weikko</strong> (e. Välähdys), som tränas av Öystein Tjomsland, debuterade i Mikkeli i mitten av september satte han stora avtryck. Hästen ledde från start till mål och landade på finska rekordet 1.26,2a/2.100 meter. Segertiden var en ren slakt av det gamla rekordet, eller en sänkning med 3,2 sekunder!</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/oysteintjomslandface-617x333.jpg" alt="" class="wp-image-474068"/><figcaption class="wp-element-caption">Öystein Tjomsland. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Ytterligare en start och seger – förstås – har det blivit för treåringen, som ikväll i Kuopio står inför årets viktigaste uppgift. Det handlar om finalen i treåringsserien Varsakunkku och hela 20.000 euro i förstapris. Öystein Tjomsland sitter som vanligt i sulkyn bakom Weikko, som har stått på Wolmsta Gård sedan han debuterade. Mentala coachen Stig Wiklund är sedan i höstas delägare i den finska hästen.</p>



<p class="wp-block-paragraph">Av Werikkos motståndare i finalen har bara en sprungit under 1.30 i karriären, stoet <strong>Neiti Sävei </strong>(e. Välähdys), som travade 1.29,2 när hon slutade tvåa vid Weikkos senaste segerlopp. Neiti Sävei har annars vunnit fyra av sex starter.</p>



<p class="wp-block-paragraph">De finska kallbloden ligger ”ett år efter” de svenska och norska. Kriteriet avgörs för fyraåringar och Derbyt för femåringar. För Weikko är säsongens mål finalen i den treåringsserie där han vann försöket i går. den avgörs i Kuopio i december med 20.000 euro i förstapris.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5MXzE0LjEwLjIwMjMucGRm&#038;m=TTqx1cj3RtdqtCDJTsWRlJzU6d0%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Kuopios tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Det är inte bara i Kuopio som det det finns svenska intressen denna fredag. Fem av de tio deltagarna i kvällens penningstinna sadellopp Seasons Monté Cup Final (€30.800) i Björneborg är svenskfödda.</p>



<p class="wp-block-paragraph">Det står 14.000 euro på spel till vinnaren när de tio deltagarna ska tävla över 2.609 meter autostart och bland dem utmärker sig den svenskfödde segermaskinen <strong>Mandela Zon </strong>(e. Maharajah) som är på jakt efter sin 24:e årsseger i vad som blir 37:e starten för säsongen.</p>



<p class="wp-block-paragraph">Miisa Pulkkanen rider det Reima Kuislas häst som är på jakt efter sin femte seger i följd.</p>



<p class="wp-block-paragraph"><strong>Startlista Seasons Monté Cup Final</strong><br><em>2.609 meter autostart</em></p>



<ol class="wp-block-list">
<li>Claude P.Hill – Eevamaija Ramirez</li>



<li>Adde S.H. – Liisa Nummi</li>



<li>Noble Superb – Joanna Karling</li>



<li>Super Schissel – Reetta Hirvonen</li>



<li>Garrett Mix – Susanna Visuri</li>



<li>Quick Diablo – Anette Antti-Roiko</li>



<li>Mandela Zon – Miisa Pulkkanen</li>



<li>Exaudio Vici – Martta Smura</li>



<li>Grainfield Aiden – Maija Fors</li>



<li>Redhot Tap Dancer – Seija Myllyharju</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Elva hästar är anmälda till kvällens internetauktion i ASVT:s regi. Merparten är fölston – nio – och dessutom säljs starthästen <strong>Vinyasa Power</strong> (e. Jaded), samt ettåriga stoet <strong>Hackels Catalina</strong> (e. Kadett C.D.).<br>Fyraåriga Vinyasa Power, som tränas av Eric Martinsson, startade så sent som i tisdags på Axevalla – och vann tillsammans med Carl Johan Jepson. Hon har gjort fyra starter i karriären.</p>



<p class="wp-block-paragraph">Bland fölstona finns döttrar till miljonärskorna <strong>Debbie Brodda</strong> (e. Credit Winner), 1.10,8am/4.188.605 kr, och <strong>Orchidee d’Aunou</strong> (e. Coktail Jet), 1.12,6ak/2.380.368 kr.</p>



<p class="wp-block-paragraph"><a href="https://auktion.asvt.se/purchase" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Fyra finaler av Danmarks motsvarighet till STL  – Travligan – avgörs under seneftermiddagen i Odense (första start kl. 15.45).<br>Förstapriset i respektive klass uppgår till 50.000 danska kronor vilket motsvarar drygt 75.000 svenska dito i dagens penningvärde och i snabbloppsklassen syns en hel del bekanta namn.</p>



<p class="wp-block-paragraph">Kosters Memorial-tvåan <strong>Emoji</strong> (e. Broad Bahn) lär få bära på favoritskapet i lag med Flemming Jensen efter den fina insatsen på 1.10,2a/1.600 meter i nämnda loppet.</p>



<p class="wp-block-paragraph"><strong>Startlista Travligan final</strong><br><em>2.140 meter autostart</em></p>



<ol class="wp-block-list">
<li>Floris Baldwin – Jeppe Juel</li>



<li>Zaffiro Jet – Magnus M Nielsen</li>



<li>Frodo Cash – Birger Jörgensen</li>



<li>Emoji – Flemming Jensen</li>



<li>Ghazi B R – Mads Henriksen</li>



<li>Stonefire U S – Kasper Foget</li>



<li>Andre Ward – Steen Juul</li>



<li>I D Exceptional – Nicklas Korfitsen</li>



<li>Golden C N – Bent Svendsen</li>
</ol>



<p class="wp-block-paragraph"><a href="https://www.epaper.dk/danskhv/fvb/odense_01-12-23/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Odense i sin helhet.</a></p>

Fokustema
Morgonsvepet
Läs senare
Premiär på Vincennes
Om Daniel Wäjerstens debut på Vincennes, svenskhopp på två finska banor under fredagskvällen samt finaldags i Odense går det bland annat att läsa om i veckans femte morgonsvep.
