
<p class="has-drop-cap wp-block-paragraph">Vi tar omtag på häst som vi singelstreckade för två veckor sedan utan lycka när det är dags för multijackpot på V75.</p>



<p class="wp-block-paragraph">Markus B Svedberg startar inte mindre än fem hästar inom Axevallas V75-omgång och allra mest tror vi på <strong>Conrads Palle </strong>(V75-6) i en spårtrappa.<br>Vi gick fullt ut på honom i ett Klass I-försök för två veckor sedan där hästen hakade på starkt efter att överlåtit taktpinnen till favoriten Jacques Mearas.<br>Nu hoppas och tror vi att Svedberg väljer att köra i ledningen och tror chansen är god att det håller hela vägen.</p>



<p class="wp-block-paragraph">Sylvesterloppet (V75-7) har samlat ett riktigt namnstarkt startfält, men det finns stora frågetecken kring hur flera av profilhästarna klarar av att tävla med skor på hovarna.<br>Det gör det däremot inte kring <strong>High On Pepper</strong> som övertygat stort stora delar av året och nu mitt under vintern tycks bättre än någonsin. Vi tror att han bara visar sig vara bäst och rundar hela gänget från 60 meters tillägg.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/12/31v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Axevalla.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-12-31_8_6" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-12-31_8_6" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-12-31_8_6" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Stolopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>I Love Faux Depart</strong> fick chansen för sent från vinnarhålet senast på Sundbyholm och gick i mål med sparade krafter utan att hota om segern. Vid fullträffen i Rättvik i november fick hon löpa ut framme i ledningen och då lämnade hon sina konkurrenter och vann helt överlägset till slut. Som spetsfavorit i det här loppet så håller vi henne också som den hetaste segerkandidaten.</li>



<li><strong>Irjas Stjärna</strong> stod för en stark insats i comebacken efter fem månaders uppehåll. Hon fick anfalla först i tredjespår sista 500 meterna, kopplade grepp och släppte blott en konkurrent förbi sig som hade fått ett mer gynnsamt lopp. Vi förväntar oss att stoet tar ett steg till på formtrappan till detta lopp och tycker att hon är väl så bra som merparten av sina konkurrenter i det här loppet.</li>



<li><strong>Brie de Meaux</strong> var med i en tuff öppning senast innan ledningen släpptes. Hon hakade på bra till slut och kan rentav haft vinstkrafter i behåll. Bold Eagle-dottern känns klart spännande i det här loppet då hon återigen har chans att få en position långt fram i fältet.</li>



<li><strong>Cascabella</strong> frontade, släppte och avgjorde på speed med knapp marginal senast på Åby. Det var en positiv insats och stoet har varit allmänt uppåt på sistone, men vanlig vagn ser vi som ett litet minus och vi tycker åtminstone inte att hon ska vara loppets favorit utan sätter henne utanför A-gruppen.</li>



<li><strong>Uberty Face</strong> har bara tre segrar på 46 starter, men är inne i en väldigt fin period just nu och kommer ta många under slutvarvet på grundstyrka.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-5-3 <strong>B: </strong>13-15-14-7-11-6-9-2 <strong>C: </strong>10-12-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>När Ulf Ohlsson får leda volten med <strong>I Love Faux Depart</strong> och har kuskar som inte är så vana att köra från springspår på Axevalla ska chansen vara god att favoriter håller upp täten.</p>



<h2 class="wp-block-heading">Avd 2 – Långlopp, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Young Andy</strong> hade övertygat stort vid segerloppen i november och det var därför överraskande att han förlorade senast på Solvalla. Då skar han ihop i travet i slutskedet och felade bort en trolig seger 50 meter före mål, men vi köper Per Lennartssons förklaring om att hästen påverkades av den lösa banan som rådde den dagen. Från andraspår kan Lennartsson köra på säkerhet initialt innan han tar sats och vi undrar om någon i den här loppet verkligen vill ta emot Up and Quick-sonen.</li>



<li><strong>Hoohoo Haahaa </strong>hade bärgat två raka segrar över just lång distans innan senaste starten. Då fick han gnugga på i tredjespår utan rygg sista 1.100 meterna och höll med tanke på det starkt som femma. Vi håller Young Andy som en bättre häst, men vid favoritfall kliver Hoohoo Haahaa in i matchen.</li>



<li><strong>Take Your Time </strong>var det spets- och släpp på senast på Åby. Han kunde inte utmana segervane Mr Weasley till slut, men höll farten berömvärt som tvåa och tillhör de bättre hästarna i det här loppet.</li>



<li><strong>Vikings Saga</strong> höll starkt som dödenstvåa senast på Åby och tar många i spurten i det här loppet om det blir minsta överpacat.</li>



<li><strong>My Great Pretender </strong>var hysteriskt osäker innan han kom till Patrik Pettersson som gjort ett jättejobb med femåringen. Även i hans regi har det blivit ett par galopper ska sägas, men intrycket vid segerloppet senast var tveklöst det rätta och även om den här hästen har en lite speciell stil så tror vi att han kommer plocka många på styrka under slutvarvet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>2 <strong>B: </strong>5-4-11-8-1-3<strong> C: </strong>10-7-6-9-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Stallkamraterna Take Your Time och Hoohoo Haahaa bör göra upp initialt. Vi säger knapp fördel för den sistnämnde, men undrar om man verkligen vill bråka med tuffe Young Andy i skede två om Per Lennartsson ställer en tidig fråga.</p>



<h2 class="wp-block-heading">Avd 3 – Stolopp, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Marabou Brodda</strong> fick en småtuff väg fram till dödspositionen senast på Jägersro innan hon blev avlöst, men avgjorde likväl relativt enkelt i slutskedet. Det känns som att stoet är riktigt på gång igen efter en lite sämre period och motståndsmässigt är detta en klart lämplig uppgift för Thomas Uhrbergs sto, men det finns viss risk att hon får göra jobb själv med startsnabba hästar på insidan som knappast skänker bort något gratis.</li>



<li><strong>Heroine Darling </strong>gick fram som en ångvält förra vintern och var även tvåa i en Bronsdivisionsfinal under Elitloppshelgen. Hon har inte startat sedan i september och är per automatik väldigt svårbedömd, men känns ändå tidig på sin tuffhet i det här loppet på det faktum att hon visat att hon kan prestera med skor på hovarna.</li>



<li><strong>N.Y.Moet </strong>har haft en mycket stark säsong i Norge med seger i Jarlsberg Grand Prix för ston och en tredjeplats i Derbystoet. Här möter hon tuffare motstånd än vad hon behövt göra när hon tävlat mot årgångskamrater i födelselandet, men vi är ändå nyfikna på hur hon kommer stå sig här.</li>



<li><strong>Stens Retention </strong>behöver ett smyglopp för att komma till sin rätt och spår åtta är inget drömläge. Däremot är fältet litet och med klaff på bitarna så tar hon många över spurtrakan.</li>



<li><strong>Benita Winner</strong> har inte visat samma storform på sistone som hon hade i våras, men såg ändå lite förbättrad ut senast i Kalmar innan galoppen kom som andrahäst 150 meter före mål.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-4 <strong>B: </strong>5-8-9-1-2 <strong>C: </strong>7-3</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Sommerbrise</strong> får svårt att svara ut <strong>N.Y.Moet</strong>. Med Jorma Kontio som kusk så tror vi att hon körs i ledningen.</p>



<h2 class="wp-block-heading">Avd 4 – Flerklasslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Coin Master</strong> är en halvbror till V75-tvåan Ready to Roll vars framtidsutsikter vi bedömer som ytterst ljusa. Hästen stod för en mycket bra comebackinsats senast på Romme där han slutade tvåa från dödens bakom ledarinnan Loulou Web på vilken han tog in meter för meter hela vägen in till mål. Får Ulf Ohlsson rätt träff från det här utgångsläget och kommer fram i duglig position direkt så tror vi att han kan tänka sig att sikta mot dödspositionen ånyo.</li>



<li><strong>King Zorro</strong> kommer också från en andraplats från dödens. Han tog emot avancemang bakifrån varvet före mål, tog över taktpinnen 500 kvar och fick blott se sig passerad av duktige Mr Weasley över spurtrakan. Det var i vårt tycke karriärens bästa insats från King Zorro som verkligen samlat ihop till att få avlägga maiden.</li>



<li><strong>Frodo de Castella</strong> var med lite i den initiala körningen senast i Gävle och hakade med tanke på det på fint som tvåa från vinnarhålet. Han har lyft undan för undan under årets avslutande månader efter att varit ifrån tävlingsbanan under sommaren och har helt rätt kurva just nu.</li>



<li><strong>Honey Dun Girl </strong>var mycket bra som dödenstvåa näst senast på Åby, men kördes på tok för offensivt senast på V75 då hon fick ånga på i för högt tempo framme i ledningen. Det gav fullt naturligt stumma ben sista 150 meterna, men vi vill ändå inte släppa henne i detta lopp då vi gillar hennes kunnande och tror hon är väl så effektiv med ett rygglopp.</li>



<li><strong>Charlie Laross </strong>har tagit två raka spetssegrar i Kalmar i enklare sällskap. Vi säger inte att det har slagit gnistor om hästen, men på sin goda startsnabbhet och fina chans att få ett bra resa långt fram i fältet är han ändå hyggligt tidig i det här loppet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>14-6 <strong>B: </strong>12-13-1-5-15-10-2-7-3-8-11-4-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Öppet mellan <strong>Charlie Laross </strong>och <strong>King Zorro</strong>, men vi håller den sistnämnde som knapp spetsfavorit.</p>



<h2 class="wp-block-heading">Avd 5 – Sprinterlopp, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>All In Face </strong>har gjort flera fina insatser även i Camilla Janssons regi under året, men han har verkligen inte sett sämre ut sedan han kom till Robert Berghs stall. Näst senast i Mantorp frontade han för att släppa till tuffe Winner Brodde och hakade på fullt godkänt till andraplatsen. Senast på Åby var det blott P 21-lopp som det handlade om, men hästen löste uppgift tillsynes okörd och såg riktigt gåvillig ut. Denna gång är han anmäld med jänkarvagn och når han tät vilket vi ser som det mest sannolika scenariot så kan han absolut hålla hela vägen.</li>



<li><strong>Judge D. </strong>vann två lopp under vintermånaderna ifjol och går en ny intressant period till mötes av senaste intrycket att döma. Då släpptes han förvisso välvilligt till ledningen, men sättet hästen joggade undan på till slut lovade mer. Även om han skulle få göra en del jobb själv i det här loppet så tror vi att han är bra nog för att utmana om segern.</li>



<li><strong>Black Fire </strong>pressade Aramis Face till galopp senast på Jägersro från dödens och försvann ifrån till överlägsen seger på en topptid. Det var hans bästa insats detta år och femåringen hävdar sig väl även i detta sammanhang.</li>



<li><strong>Conch On Inn </strong>satt fast med sparade krafter i tredje invändigt senast i Bollnäs. Han har god chans att åtminstone hålla rygg på ledaren i det här loppet och då är han en faktor att räkna med.</li>



<li><strong>Hashtag Simoni </strong>är i knallform, men från spår tolv över sprinterdistans känns den här uppgiften mycket svår oavsett hur långt upploppet på Axevalla än må vara.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>4-2-6-1 <strong>B: </strong>12-11-5-7-9 <strong>C: </strong>8-3-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Öppnar <strong>All In Face </strong>lika bra som näst senast i Mantorp har han alla möjligheter att komma förbi <strong>Conch On Inn</strong> och <strong>Judge D. </strong>direkt.</p>



<h2 class="wp-block-heading">Avd 6 – Spårtrappa, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Conrads Palle </strong>trodde vi stenhårt på senast i Bollnäs efter den övertygande dödenstriumfen i Örebro näst senast. Loppet började också lovande då han kunde forceras till tät efter första kurvan, men därefter valde Markus B Svedberg att släppa ledningen till favoriten Jacques Mearas. I dennes rygg blev han sedan kvar hela vägen och fullföljde mycket bra till andraplatsen utan att se plågad ut över målgången. Vi var en smula överraskade över det taktiska valet med tanke på hur rejält hästen uppträdde gången innan, men hoppas att Svedberg är mer påställd nu och väljer att köra i ledningen dit vi tror att han har god chans att nå på nytt.</li>



<li><strong>Klondyke River </strong>fick en pangstart från dubbla tillägg senast på Åby och kunde köras till tät i andra kurvan. Därefter hade han inga som helst planer på att släppa någon förbi sig i det stayerloppet och intrycket var riktigt rejält. Med klaff på bitarna är han med långt fram på nytt.</li>



<li><strong>Cassius Clay D.E. </strong>såg fräck ut med lopp i kroppen senast i Kalmar och med jänkarvagn på för första gången. Han tog dödens inför slutrundan och avgjorde tillsynes okörd. Femåringen har mer pengar att tjäna och duger även här om han &#8221;bara&#8221; kommer till från spår åtta.</li>



<li><strong>J.S.Camaro </strong>var aldrig nära att förlora genrepet inför detta lopp på Axevalla efter att nått ledningen i tidigt skede. Dit kommer han inte nu, men hästen gör även bra lopp bakifrån.</li>



<li><strong>Utah Southwind </strong>tycker vi har visat hög högstanivå i Norge, men han har blandat det med en del djupa dalar. Här gör fyraåringen spännande debut i Ulf Stenströmers regi och då han har chans att hamna långt fram i fältet direkt så tycker vi att Bold Eagle-sonen känns som loppets givna &#8221;dark horse&#8221;.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6 <strong>B: </strong>11-8-10-2-3-9-1-5-13-4 <strong>C: </strong>15-14-7-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vårt tips bygger på att<strong> Conrads Palle</strong> dyker till tät och att Markus B Svedberg nu bestämmer sig för att pröva att köra i den positionen.</p>



<h2 class="wp-block-heading">Avd 7 – Sylvesterloppet, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>High On Pepper</strong> har mer eller mindre radat upp toppinsatser hela året, men frågan är ändå om han inte ser bättre ut än någonsin tidigare för dagen. Efter den övertygande och överlägsna segern i Hästägarkannan på Solvalla så vann han Gulddivisionsloppet i Bollnäs vecka före jul trots tredjespår utan rygg de sista 1.200 meterna utan att Jorma Kontio såg ut att kräva extraväxeln av Ready Cash-sonen. Konkurrens saknas inte på pappret, men flera av de mer namnkunniga motståndarna är hämmade av att tävla med skor vilket inte alls är ett lika stort problem för High On Peppers del.</li>



<li><strong>Demon</strong> blev fint framdragen i Axel Jensens Minneslopp på Bjerke och då hade han inga problem att avgöra i spurten på urstarka 1.10,4a/1.609 meter. Gången efter startade han i Grupp I-loppet Gran Premio Unione Europea i Modena och blev tillsynes störd till galopp i andra utvändigt i slutkurvan. Demon är en kanonhäst som kommer kunna etablera sig i eliten vad det lider, men har inte tävlat med skor runt om under hela fyraåringssäsongen och för oss är det ett stort frågetecken hur det påverkar hans förmåga att hävda sig i såhär tuff konkurrens.</li>



<li><strong>Unico Broline</strong> vann lekande lätt efter forcering till tät mitt i loppet näst senast på Vincennes, men gången efter tröt krafterna efter att han forcerats fram till dödens i uppförsbacken i alltför högt tempo. Sjuåringen har faktiskt fyra segrar och en andraplats på sina fem senaste starter med skor på hovarna så han behöver inte vara lika påverkad som flera andra kan vara i det här loppet, men för oss är High On Pepper en bättre häst när det kommer till tävling över lång distans.</li>



<li><strong>Michigan Bro</strong> har galopperat bort sig i såväl Breeders Crown-finalen som ett Bronsdivisionsförsök och står alltämt kvar i en låg klass. Vi är verkligen svaga för den här hästen och skulle Markus B Svedberg lyckas forcera sina springare till tät i tidigt skede från 20 meters tillägg med få hästar på startvolten så är inte Michigan Bro chanslös.</li>



<li><strong>Power</strong> har studsat tillbaka med besked i år, vunnit Svenskt Mästerskap på tangerat världsrekord och tjänat över två miljoner kronor. Här blir det dock tävling med skor på hovarna och med Prix d&#8217;Amerique i sikte från Robert Berghs sida så undrar vi om formen verkligen är på topp redan nu.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 15 <strong>B: </strong>10-14-5-13-9-12 <strong>C: </strong>11-6-8-1-3-4-2-7</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Star Cash</strong> tar ledningen i första skedet, men kan få <strong>Michigan Bro</strong> över sig per omgående och då undrar vi om verkligen Adrian Kolgjini vill ta emot när det är så otroligt fina pengar att tävla om även om platserna bakom vinnaren.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 31 DECEMBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,3,5 (13,15)<br><strong>Avd 2: </strong>2,4,5,11 (8,1)<br><strong>Avd 3: </strong>1,4,5,6,8,9 (2,7)<br><strong>Avd 4: </strong>1,2,3,5,6,7,10,12,13,14,15 (8,11)<br><strong>Avd 5:</strong> 1,2,4,6,12 (11,5)<br><strong>Avd 6: </strong>6 Conrads Palle (11,8)<br><strong>Avd 7: </strong>15 High On Pepper (10,14)</p>



<p class="wp-block-paragraph"><em>3.960 rader / 1.890 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
