
<p class="has-drop-cap">1Han har sprungit in nio miljoner kronor de tre föregående säsongerna, men i år är norske storstjärnan <strong>Moni Viking</strong> (e. Maharajah) fortsatt segerlös efter fem starter och en tredjeplats som bäst. Efter halvårslångt uppehåll är han tillbaka på tävlingsbanan på Solvalla i eftermiddag när Björn Goop plockar ut tioåringen i gulddivisionen Frances Bulwarks/Olle Anderssons lopp.</p>



<p>Det blir första starten sedan Moni Viking slutade trea i Oslo Grand Prix i juni och tränaren Björn Goop utlovar ingen toppform.<br>– Han känns fin, men är lite rund om magen än så länge. Han har några extra kilo runt magen och är inte på topp. Jag hade först tänkt starta på Åby veckan efter, men jag avstängd då så det blev en vecka tidigare. Han är tillräckligt bra för att kunna vinna, men det är comeback och han ska tävla med skor, så jag inte blir besviken om han inte vinner, sade Björn Goop till ATG Live.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/francesbulwarknordin-617x347.jpg" alt="" class="wp-image-222053"/><figcaption class="wp-element-caption">Frances Bulwark vann Svenskt Mästerskap sex gånger tillsammans med Sören Nordin. Foto Stalltz.se</figcaption></figure>



<p>Gulddivisionen är en hyllning till Sveriges travdrottning <strong>Frances Bulwark</strong> (född 1945 e. Bulwark). 80 segrar, 21 andraplatser och tolv tredjepris blev resultatet under den 130 starter långa och mycket framgångsrika karriären hos Sören Nordin. <br>Frances Bulwark var totalt överlägsen i sin samtid i Sverige. Sex segrar i SM, fem i Skandinaviskt Mästerskap, fem i C.L.Müllers Memorial. Frances Bulwark fick tävla utanför toton för att hon var så överlägsen. Hon placerades med en massa tillägg.<br>Frances Bulwark vann det andra Elitloppet som kördes, 1953. När hon reste ut i Europa dög hon också. Seger i Nationernas Pris i Milano 1952, tvåa i Prix d’Amérique 1954.</p>



<p>Vid Frances Bulmarks sida runt om Europa fanns hästskötaren Olle Andersson och tillsammans delar den dynamiska duon rubriken till dagens gulddivision.</p>



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



<p class="has-drop-cap">2Katja Melkko har tvingats stryka <strong>Happy Go Pepper</strong> (e. Muscle Hill) från den tilltänkta V75-starten idag på grund av halsinfektion. Är det fara å färde för Sulkysports förslag till singelstreck <strong>High On Pepper</strong> (e. Ready Cash) i stayerloppet över drygt tre varv?<br>– Vi har något virus i stallet. Vi har kollat High On Pepper, han är helt frisk och har inga problem. Han känns som tidigare och var normal i ett jobb i torsdags. Han kollades igen efteråt och är helt frisk, sade Katja Melkko till V65 Direkt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/13highonpepper-617x333.jpg" alt="" class="wp-image-358810"/><figcaption class="wp-element-caption">Invändige High On Pepper vid en tidigare seger på Solvalla. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>High On Pepper har tävlat på barfotabalans i sina fem senaste starter, däribland tre starter barfota runt om, men att det är skotvång idag oroar inte tränaren det minsta.<br>– Han har tävlat mest med skor. I de senaste starterna har han varit tillräckligt stark och travat bra, så han har kunnat tävla utan skor. Att tävla med i inga problem och förra vintern öppnade han till exempel jättebra med brodd på vinterunderlag, så jag tror att han trivs med det. Vi pratade med Jorma om matchningen och om vi skulle starta i gulddivisionen med autostart istället för det här loppet med volt och han sade att starten inte är några problem, sade Katja Melkko.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-solvalla-2-december/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång inför V75.</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_2023-12-02_5_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-12-02_5_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-12-02_5_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p>Förutom huvudtävlingarna på Solvalla blir det både förmiddagstrav och kvällstrav på svensk mark. Det bjuds breddlopp både på Åby (start 11.10) och i Östersund (start 18.50).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/231202.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">3På Vincennes (första start kl. 13.23) avgörs det dubbla semi classique-lopp under eftermiddagen och det finns svenskintressen i båda. Jörgen Westholms <strong>Imhatra Am</strong> (e. Muscle Hill) är tillbaka på fransk mark och tävlar i Prix Doynel de Saint-Quentin (€120.000), där hon körs av Matthieu Abrivard. <br>Konkurrensen är stentuff och bland motståndarna utmärker sig landets bästa femåring <strong>Idao de Tillard</strong> (e. Severino), som tillhör absoluta favoritskaran inför Prix d&#8217;Amérique.</p>



<p>I Prix Raoul Balliere (€120.000) är det Tomas Malmqvist som är i farten. Då med <strong>Kobalt du Vallon</strong> (e. Quaker Jet) som tar striden för sadel i lag med Tomas Malmqvist.<br>Montélopp handlar det även om i Prix de la Clayette (€49.000) och där syns exporterna <strong>Beethoven</strong> (e. From Above) samt <strong>Silver Bullit</strong> (e. Orlando Vici) bland deltagarna.<br>Övriga blågula hopp på Vincennes är Malmqvist <strong>Looping Day</strong> (e. Face Time Bourbon) i Prix des Dhalias (€43.000) och Jarmo Niskanens <strong>Jingalo Babel</strong> (e. Singalo) i Prix d’Oraison (€35.000).</p>



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



<p>Gårdagens svenska framgång ordnade Marie Norberg när hennes <strong>Justess Viking</strong> (e. Ubriaco) tog tredjeplatsen i Prix Gienah (€35.000).</p>



<p><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – Tränare – Placering – Prispengar</em></p>



<ul class="wp-block-list">
<li>Justess Viking (e. Ubriaco) – Marie Norberg – trea – 4.900 euro</li>



<li>G.K.Justus (e. Brad de Veluwe) – Stefan Arvidsson – sexa 920 euro</li>



<li>Titan Yoda (e. Ready Cash) – Daniel Wäjersten – dg</li>



<li>Twigs Honor (e. Voltigeur de Myrt) – Björn Goop – dg </li>



<li>Koko Labelle (e. Charly du Noyer) – Ron Kuiper – dg</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/img2051-617x387.jpg" alt="" class="wp-image-482546"/><figcaption class="wp-element-caption">Just Hans och Bent Svendsen. Foto Kjeld Mikkelsen/KM FOTO</figcaption></figure>



<p class="has-drop-cap">4Maharajah-sonen <strong>Just Hans</strong> är nummer ett i den danska kullen född 2020 efter att ha vunnit både Kriteriet och Jydsk 3-årings Grand Prix och hästen har på 14 starter (10-3-0) sprungit in 1.371.000 danska kronor. Detta har han gjort som hingst – nu är Just Hans kastrerad!</p>



<p>Danska sajten <a href="http://travservice.dk">travservice.dk</a> berättar om ingreppet som gjordes i torsdags.<br>– När han går i hagen blir han aggressiv om andra hästar går förbi och han biter kraftigt i staketet. Det var först i samband när han skulle ut och in från hagen som han blev så hingstig. På stallgången var han den smartaste hästen, men runt hagen blev han för våldsam och för farlig för oss att hantera, säger tränaren Bent Svendsen till Travservice.<br>Svendsen är inte orolig för den kommande Derbysäsongen, då ingreppet gjorts i så pass god tid inför uppträningen för Derbyt.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/weikko-617x333.jpg" alt="" class="wp-image-529756"/><figcaption class="wp-element-caption">Så här överlägsen var Öystein Tjomslands finska kallblod i Finlands största treåringslopp. Skärmbild Veikkaus tv</figcaption></figure>



<p class="has-drop-cap">5Öystein Tjomslands första försök med ett finskt kallblod fortsätter i succéartad stil. Igår på vinterbana i Kuopio plockade treårige finnhästen <strong>Weikko</strong> (e. Välähdys) hem kullens största lopp, finalen i treåringsserien Varsakunkku med 20.000 euro i förstapris.</p>



<p>Största hotet på förhand var 20 meter före startande stoet <strong>Neiti Sävei</strong> (e. Välähdys), som anförde till kilometern från mål då Weikko kom ikapp pch klev förbi. Neiti Sävei hakade på fint till det blev tvärstopp 500 meter från mål och då stack Weiko undan med många längder och segermarginalen blev närmare 80 meter på 1.29,2/2.120 meter.<br>Weikko ägs av Tjomsland, uppfödaren Pekka Lillbacka och svenske idrottspsykologen Stig Wiklund.</p>



<p>Kriteriet för finska kallblod körs nästa och år Derbyt för femåringar, men Weikko har nu inlett med tre segrar på lika många starter och sprungit in 30.000 euro, eller 326.940 kronor. Rekordet 1.26,2a/2.100 meter från tävlingsdebuten var finskt rekord med över tre sekunder!</p>



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



<p class="has-drop-cap">6Med seger på 1.15,9/1.640 meter voltstart förra veckan i bagaget är tvååriga stoet <strong>Kilimanjaro Face</strong> (e. Googoo Gaagaa) en av 38 hästar som bjuds ut till försäljning på Traveras internetauktion ikväll. Det danskfödda stoet galopperade i debuten, men har sedan även varit tvåa på 1.16,0 och gjort tre starter totalt.</p>



<p>Travera har 18 starthästar och lika många fölston i den digitala katalogen. Bland fölstona finns toppstammade norska stoet <strong>Nice Eleven L.</strong> (e. Coktail Jet), som kommer från Nevele Nows möderne. Nice Eleven L. vann tio av 18 starter, däribland norska Oaks, och slutade tvåa i Stoderbyt. Hon är dräktig med franske Boccador de Simm.</p>



<p><a rel="noreferrer noopener" href="https://www.travera.nu/kopa-hast/" target="_blank"> Här går det att se hästarna som bjuds ut och följa budgivni</a><a rel="noreferrer noopener" href="https://www.travera.nu/kopa-hast/" target="_blank">ngen under kvällen.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/petrisalmela-617x333.jpg" alt="" class="wp-image-352655"/><figcaption class="wp-element-caption">Petri Salmela. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">7Det väntas stora årgångsfinaler i finska Seinäjoki i eftermiddag när det är dags för Breeders Crown-finalerna – Kasvattajakruun (€66.000) – med 30.000 euro i förstapris i varje. Både tre- och fyraåringar gör upp om titlarna och årets största vinnare finns med i varsin final. Det handlar om Derbyvinnaren <strong>Crepe Match</strong> (e. Creatine) och Kriterievinnaren <strong>God Hyperion</strong> (e. Brad de Veluwe). Crepe Match vann sitt försök, medan God Hyperion fick stryk i sitt uttagningslopp.</p>



<p>En svensktränad – och dessutom svenskfödd – häst är med i finalerna och Mika Forss reser till hemlandet för att köra Petri Salmelas treåriga sto <strong>Caia</strong> (e. Cantab Hall), som var sexa i sitt försök. Caia anlände till Salmelas stall i höstas och vann ett treåringslopp på Solvalla på 1.12,4ak för 1,5 månader sedan. Totalt har Caia vunnit två av 14 starter och sprungit in 227.151 kronor.</p>



<p>Bland avelshingstarna dominerar Sveriges champion Maharajah stort. Han av avkommor till start i alla fyra finaler och totalt startar nio söner och döttrar.</p>



<p>Här är startlistorna till de finska finalerna som avgörs över 2.100 meter med autostart.</p>



<h2 class="wp-block-heading">Treåriga h/v:</h2>



<ol class="wp-block-list">
<li>Sahara Commander (e. R.C.Royalty) – Tommi Kylliäinen</li>



<li>Mas Henri (e. The Bosses Lindy) – Santtu Raitala</li>



<li>Fly By Me (e. Muscle Mass) – Harri Koivunen</li>



<li>Khopesh (e. Maharajah) – Juha Utala</li>



<li>Cool Flame (e. Flocki d’Aurcy) – Antti Teivainen</li>



<li>Magical Prince (e. Muscle Mass) – Pekka Korpi</li>



<li>Long Leg (e. Express Duo) – Kari Venäläinen</li>



<li>Sahara Vision (e. R.C.Royalty) – Tino Paldan</li>



<li>Madrero (e. Maharajah) – Hannu Torvinen</li>



<li>God Hyperion (e. Brad de Veluwe) – Henri Bollström</li>



<li>Wille’s Shaman (e. R.C.Royalty) – Niko Jokela</li>



<li>Karelin Avenger (e. Le Monteil) – Olli Koivunen</li>
</ol>



<h2 class="wp-block-heading">Treåriga ston:</h2>



<ol class="wp-block-list">
<li>Callela Xplosion (e. Explosive Matter) – Tommi Ala-Nikkola</li>



<li>Icella (e. Maharajah) – Antti Teivainen</li>



<li>Extrema (e. Extrema (e. Maharajah) – Olli Koivunen</li>



<li>Bring It On Home (e. Brillantissime) – Tommi Kylliäinen</li>



<li>Lady Cheri (e. Crazed) – Henna Halme</li>



<li>Sands Hybrid (e. Maharajah) – Ari Moilanen</li>



<li>An-Lisa (e. Lexus Font) – Robert Lindgren</li>



<li>Caia (e. Cantab Hall) – Mika Forss</li>



<li>Viens Ici (e. Quite Easy) – Santtu Raitala</li>



<li>Christine L Garden (e. Maharajah) – Hannu Torvinen</li>



<li>Nothingcomes (e. Coktail Jet) – Henri Bollström</li>



<li>Amanda Evo (e. Brillantissime) – struken</li>
</ol>



<h2 class="wp-block-heading">Fyraåriga h/v:</h2>



<ol class="wp-block-list">
<li>Massimo Hoist (e. Muscle Hill) – Mika Forss</li>



<li>Crepe Match (e. Creatine) – Olli Koivunen</li>



<li>Amazing Player (e. Quite Easy ) – Jarmo Saarela</li>



<li>Blackbeard (e. R.C.Royalty) – Jukka Torvinen</li>



<li>Callela Nelson (e. Beer Summit) – Hannu Torvinen</li>



<li>Laxvikens Amiral (e. Jontte Boy) – Tuomas Korvenoja</li>



<li>Piece Of Battle (e. Brillantissime) – Henri Bollström</li>



<li>The Big Payback (e. Big Apple Deli) – Niko Jokela</li>



<li>Sahara Dangerous (e. Raja Mirchi) – Santtu Raitala</li>



<li>Callela Alfa (e. Classic Photo) – Tapio Perttunen</li>



<li>Lakes’s Elmer (e. Atlas de Joudes) – Tommi Kylliäinen</li>



<li>American Cooper (e. Maharajah) – Ari Moilanen</li>
</ol>



<h2 class="wp-block-heading">Fyraåriga ston:</h2>



<ol class="wp-block-list">
<li>Marier Mili (e. Jontte Boy) – Hannu Torvinen</li>



<li>Dorea Frido (e. Muscle Hill) – Antti Teivainen</li>



<li>Star Angus (e. Andover Hall) – Tommi Kylliäinen</li>



<li>Halley Wania (e. EL Titan) – Santtu Raitala</li>



<li>Carla Combo (e. Maharajah) – Pekka Korpi</li>



<li>Callela Ladybird (e. Quite Easy) – Ari Moilanen</li>



<li>Take Care (e. S.J.’s Photo) – Hannu Kamppuri</li>



<li>Aurora Comery (e. Quite Easy) – Emma Väre</li>



<li>Ranch Whodidwhat (e. Maharajah) – Mika Forss</li>



<li>Kiikku’s Nea (e. Nuncio) – Juha Utala</li>



<li>Fortunewheelgarden (e. Trixton) – Olli Koivunen</li>



<li>Rivercapes Frozen (e. Nuncio) – Heikki Mikkonen</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
”Han är lite rund om magen”
Goop om läget med Moni Viking. Årets Kriterievinnare kasterad. Svenskt sto mot Prix d’Amérique-kandidat. Tvååringsvinnare säljs på auktion. Salmela i stor finsk final.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
